aws_sdk_s3/config/
endpoint.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2pub use ::aws_smithy_runtime_api::client::endpoint::EndpointFuture;
3pub use ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver;
4pub use ::aws_smithy_types::endpoint::Endpoint;
5
6/// Interceptor that tracks endpoint override business metric.
7#[derive(Debug, Default)]
8pub(crate) struct EndpointOverrideFeatureTrackerInterceptor;
9
10impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EndpointOverrideFeatureTrackerInterceptor {
11    fn name(&self) -> &'static str {
12        "EndpointOverrideFeatureTrackerInterceptor"
13    }
14
15    fn read_before_execution(
16        &self,
17        _context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<'_>,
18        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
19    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
20        if cfg.load::<::aws_types::endpoint_config::EndpointUrl>().is_some() {
21            cfg.interceptor_state()
22                .store_append(::aws_runtime::sdk_feature::AwsSdkFeature::EndpointOverride);
23        }
24        ::std::result::Result::Ok(())
25    }
26}
27
28#[cfg(test)]
29mod test {
30
31    /// region is not a valid DNS-suffix
32    #[test]
33    fn test_1() {
34        let params = crate::config::endpoint::Params::builder()
35            .region("a b".to_string())
36            .use_fips(false)
37            .use_dual_stack(false)
38            .accelerate(false)
39            .build()
40            .expect("invalid params");
41        let resolver = crate::config::endpoint::DefaultResolver::new();
42        let endpoint = resolver.resolve_endpoint(&params);
43        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [region is not a valid DNS-suffix]");
44        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
45    }
46
47    /// Invalid access point ARN: Not S3
48    #[test]
49    fn test_2() {
50        let params = crate::config::endpoint::Params::builder()
51            .region("us-east-1".to_string())
52            .use_fips(false)
53            .use_dual_stack(false)
54            .accelerate(false)
55            .bucket("arn:aws:not-s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
56            .build()
57            .expect("invalid params");
58        let resolver = crate::config::endpoint::DefaultResolver::new();
59        let endpoint = resolver.resolve_endpoint(&params);
60        let error =
61            endpoint.expect_err("expected error: Invalid ARN: The ARN was not for the S3 service, found: not-s3 [Invalid access point ARN: Not S3]");
62        assert_eq!(format!("{}", error), "Invalid ARN: The ARN was not for the S3 service, found: not-s3")
63    }
64
65    /// Invalid access point ARN: invalid resource
66    #[test]
67    fn test_3() {
68        let params = crate::config::endpoint::Params::builder()
69            .region("us-east-1".to_string())
70            .use_fips(false)
71            .use_dual_stack(false)
72            .accelerate(false)
73            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint:more-data".to_string())
74            .build()
75            .expect("invalid params");
76        let resolver = crate::config::endpoint::DefaultResolver::new();
77        let endpoint = resolver.resolve_endpoint(&params);
78        let error = endpoint.expect_err("expected error: Invalid ARN: The ARN may only contain a single resource component after `accesspoint`. [Invalid access point ARN: invalid resource]");
79        assert_eq!(
80            format!("{}", error),
81            "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`."
82        )
83    }
84
85    /// Invalid access point ARN: invalid no ap name
86    #[test]
87    fn test_4() {
88        let params = crate::config::endpoint::Params::builder()
89            .region("us-east-1".to_string())
90            .use_fips(false)
91            .use_dual_stack(false)
92            .accelerate(false)
93            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:".to_string())
94            .build()
95            .expect("invalid params");
96        let resolver = crate::config::endpoint::DefaultResolver::new();
97        let endpoint = resolver.resolve_endpoint(&params);
98        let error = endpoint.expect_err("expected error: Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided [Invalid access point ARN: invalid no ap name]");
99        assert_eq!(
100            format!("{}", error),
101            "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided"
102        )
103    }
104
105    /// Invalid access point ARN: AccountId is invalid
106    #[test]
107    fn test_5() {
108        let params = crate::config::endpoint::Params::builder()
109            .region("us-east-1".to_string())
110            .use_fips(false)
111            .use_dual_stack(false)
112            .accelerate(false)
113            .bucket("arn:aws:s3:us-west-2:123456_789012:accesspoint:apname".to_string())
114            .build()
115            .expect("invalid params");
116        let resolver = crate::config::endpoint::DefaultResolver::new();
117        let endpoint = resolver.resolve_endpoint(&params);
118        let error = endpoint.expect_err("expected error: Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123456_789012` [Invalid access point ARN: AccountId is invalid]");
119        assert_eq!(
120            format!("{}", error),
121            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123456_789012`"
122        )
123    }
124
125    /// Invalid access point ARN: access point name is invalid
126    #[test]
127    fn test_6() {
128        let params = crate::config::endpoint::Params::builder()
129            .region("us-east-1".to_string())
130            .use_fips(false)
131            .use_dual_stack(false)
132            .accelerate(false)
133            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:ap_name".to_string())
134            .build()
135            .expect("invalid params");
136        let resolver = crate::config::endpoint::DefaultResolver::new();
137        let endpoint = resolver.resolve_endpoint(&params);
138        let error = endpoint.expect_err("expected error: Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `ap_name` [Invalid access point ARN: access point name is invalid]");
139        assert_eq!(
140            format!("{}", error),
141            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `ap_name`"
142        )
143    }
144
145    /// Access points (disable access points explicitly false)
146    #[test]
147    fn test_7() {
148        let params = crate::config::endpoint::Params::builder()
149            .region("us-east-1".to_string())
150            .use_fips(false)
151            .use_dual_stack(false)
152            .accelerate(false)
153            .disable_access_points(false)
154            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
155            .build()
156            .expect("invalid params");
157        let resolver = crate::config::endpoint::DefaultResolver::new();
158        let endpoint = resolver.resolve_endpoint(&params);
159        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
160        assert_eq!(
161            endpoint,
162            ::aws_smithy_types::endpoint::Endpoint::builder()
163                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
164                .property(
165                    "authSchemes",
166                    vec![{
167                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
168                        out.insert("name".to_string(), "sigv4".to_string().into());
169                        out.insert("signingName".to_string(), "s3".to_string().into());
170                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
171                        out.insert("disableDoubleEncoding".to_string(), true.into());
172                        out
173                    }
174                    .into()]
175                )
176                .build()
177        );
178    }
179
180    /// Access points: partition does not support FIPS
181    #[test]
182    fn test_8() {
183        let params = crate::config::endpoint::Params::builder()
184            .region("cn-north-1".to_string())
185            .use_fips(true)
186            .use_dual_stack(false)
187            .accelerate(false)
188            .bucket("arn:aws:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
189            .build()
190            .expect("invalid params");
191        let resolver = crate::config::endpoint::DefaultResolver::new();
192        let endpoint = resolver.resolve_endpoint(&params);
193        let error = endpoint.expect_err("expected error: Partition does not support FIPS [Access points: partition does not support FIPS]");
194        assert_eq!(format!("{}", error), "Partition does not support FIPS")
195    }
196
197    /// Bucket region is invalid
198    #[test]
199    fn test_9() {
200        let params = crate::config::endpoint::Params::builder()
201            .region("us-east-1".to_string())
202            .use_fips(false)
203            .use_dual_stack(false)
204            .accelerate(false)
205            .disable_access_points(false)
206            .bucket("arn:aws:s3:us-west -2:123456789012:accesspoint:myendpoint".to_string())
207            .build()
208            .expect("invalid params");
209        let resolver = crate::config::endpoint::DefaultResolver::new();
210        let endpoint = resolver.resolve_endpoint(&params);
211        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-west -2` (invalid DNS name) [Bucket region is invalid]");
212        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-west -2` (invalid DNS name)")
213    }
214
215    /// Access points when Access points explicitly disabled (used for CreateBucket)
216    #[test]
217    fn test_10() {
218        let params = crate::config::endpoint::Params::builder()
219            .region("us-east-1".to_string())
220            .use_fips(false)
221            .use_dual_stack(false)
222            .accelerate(false)
223            .disable_access_points(true)
224            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
225            .build()
226            .expect("invalid params");
227        let resolver = crate::config::endpoint::DefaultResolver::new();
228        let endpoint = resolver.resolve_endpoint(&params);
229        let error = endpoint.expect_err("expected error: Access points are not supported for this operation [Access points when Access points explicitly disabled (used for CreateBucket)]");
230        assert_eq!(format!("{}", error), "Access points are not supported for this operation")
231    }
232
233    /// missing arn type
234    #[test]
235    fn test_11() {
236        let params = crate::config::endpoint::Params::builder()
237            .region("us-east-1".to_string())
238            .use_fips(false)
239            .use_dual_stack(false)
240            .accelerate(false)
241            .disable_access_points(true)
242            .bucket("arn:aws:s3:us-west-2:123456789012:".to_string())
243            .build()
244            .expect("invalid params");
245        let resolver = crate::config::endpoint::DefaultResolver::new();
246        let endpoint = resolver.resolve_endpoint(&params);
247        let error = endpoint.expect_err("expected error: Invalid ARN: `arn:aws:s3:us-west-2:123456789012:` was not a valid ARN [missing arn type]");
248        assert_eq!(
249            format!("{}", error),
250            "Invalid ARN: `arn:aws:s3:us-west-2:123456789012:` was not a valid ARN"
251        )
252    }
253
254    /// SDK::Host + access point + Dualstack is an error
255    #[test]
256    fn test_12() {
257        let params = crate::config::endpoint::Params::builder()
258            .accelerate(false)
259            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
260            .force_path_style(false)
261            .endpoint("https://beta.example.com".to_string())
262            .region("cn-north-1".to_string())
263            .use_dual_stack(true)
264            .use_fips(false)
265            .build()
266            .expect("invalid params");
267        let resolver = crate::config::endpoint::DefaultResolver::new();
268        let endpoint = resolver.resolve_endpoint(&params);
269        let error = endpoint.expect_err(
270            "expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + access point + Dualstack is an error]",
271        );
272        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
273    }
274
275    /// Access point ARN with FIPS & Dualstack
276    #[test]
277    fn test_13() {
278        let params = crate::config::endpoint::Params::builder()
279            .region("us-east-1".to_string())
280            .use_fips(true)
281            .use_dual_stack(true)
282            .accelerate(false)
283            .disable_access_points(false)
284            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
285            .build()
286            .expect("invalid params");
287        let resolver = crate::config::endpoint::DefaultResolver::new();
288        let endpoint = resolver.resolve_endpoint(&params);
289        let endpoint =
290            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com");
291        assert_eq!(
292            endpoint,
293            ::aws_smithy_types::endpoint::Endpoint::builder()
294                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com")
295                .property(
296                    "authSchemes",
297                    vec![{
298                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
299                        out.insert("name".to_string(), "sigv4".to_string().into());
300                        out.insert("signingName".to_string(), "s3".to_string().into());
301                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
302                        out.insert("disableDoubleEncoding".to_string(), true.into());
303                        out
304                    }
305                    .into()]
306                )
307                .build()
308        );
309    }
310
311    /// Access point ARN with Dualstack
312    #[test]
313    fn test_14() {
314        let params = crate::config::endpoint::Params::builder()
315            .region("us-east-1".to_string())
316            .use_fips(false)
317            .use_dual_stack(true)
318            .accelerate(false)
319            .disable_access_points(false)
320            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
321            .build()
322            .expect("invalid params");
323        let resolver = crate::config::endpoint::DefaultResolver::new();
324        let endpoint = resolver.resolve_endpoint(&params);
325        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.dualstack.us-west-2.amazonaws.com");
326        assert_eq!(
327            endpoint,
328            ::aws_smithy_types::endpoint::Endpoint::builder()
329                .url("https://myendpoint-123456789012.s3-accesspoint.dualstack.us-west-2.amazonaws.com")
330                .property(
331                    "authSchemes",
332                    vec![{
333                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
334                        out.insert("name".to_string(), "sigv4".to_string().into());
335                        out.insert("signingName".to_string(), "s3".to_string().into());
336                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
337                        out.insert("disableDoubleEncoding".to_string(), true.into());
338                        out
339                    }
340                    .into()]
341                )
342                .build()
343        );
344    }
345
346    /// vanilla MRAP
347    #[test]
348    fn test_15() {
349        let params = crate::config::endpoint::Params::builder()
350            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
351            .region("us-east-1".to_string())
352            .disable_multi_region_access_points(false)
353            .use_fips(false)
354            .use_dual_stack(false)
355            .accelerate(false)
356            .build()
357            .expect("invalid params");
358        let resolver = crate::config::endpoint::DefaultResolver::new();
359        let endpoint = resolver.resolve_endpoint(&params);
360        let endpoint = endpoint.expect("Expected valid endpoint: https://mfzwi23gnjvgw.mrap.accesspoint.s3-global.amazonaws.com");
361        assert_eq!(
362            endpoint,
363            ::aws_smithy_types::endpoint::Endpoint::builder()
364                .url("https://mfzwi23gnjvgw.mrap.accesspoint.s3-global.amazonaws.com")
365                .property(
366                    "authSchemes",
367                    vec![{
368                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
369                        out.insert("name".to_string(), "sigv4a".to_string().into());
370                        out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
371                        out.insert("signingName".to_string(), "s3".to_string().into());
372                        out.insert("disableDoubleEncoding".to_string(), true.into());
373                        out
374                    }
375                    .into()]
376                )
377                .build()
378        );
379    }
380
381    /// MRAP does not support FIPS
382    #[test]
383    fn test_16() {
384        let params = crate::config::endpoint::Params::builder()
385            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
386            .region("us-east-1".to_string())
387            .disable_multi_region_access_points(false)
388            .use_fips(true)
389            .use_dual_stack(false)
390            .accelerate(false)
391            .build()
392            .expect("invalid params");
393        let resolver = crate::config::endpoint::DefaultResolver::new();
394        let endpoint = resolver.resolve_endpoint(&params);
395        let error = endpoint.expect_err("expected error: S3 MRAP does not support FIPS [MRAP does not support FIPS]");
396        assert_eq!(format!("{}", error), "S3 MRAP does not support FIPS")
397    }
398
399    /// MRAP does not support DualStack
400    #[test]
401    fn test_17() {
402        let params = crate::config::endpoint::Params::builder()
403            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
404            .region("us-east-1".to_string())
405            .disable_multi_region_access_points(false)
406            .use_fips(false)
407            .use_dual_stack(true)
408            .accelerate(false)
409            .build()
410            .expect("invalid params");
411        let resolver = crate::config::endpoint::DefaultResolver::new();
412        let endpoint = resolver.resolve_endpoint(&params);
413        let error = endpoint.expect_err("expected error: S3 MRAP does not support dual-stack [MRAP does not support DualStack]");
414        assert_eq!(format!("{}", error), "S3 MRAP does not support dual-stack")
415    }
416
417    /// MRAP does not support S3 Accelerate
418    #[test]
419    fn test_18() {
420        let params = crate::config::endpoint::Params::builder()
421            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
422            .region("us-east-1".to_string())
423            .disable_multi_region_access_points(false)
424            .use_fips(false)
425            .use_dual_stack(false)
426            .accelerate(true)
427            .build()
428            .expect("invalid params");
429        let resolver = crate::config::endpoint::DefaultResolver::new();
430        let endpoint = resolver.resolve_endpoint(&params);
431        let error = endpoint.expect_err("expected error: S3 MRAP does not support S3 Accelerate [MRAP does not support S3 Accelerate]");
432        assert_eq!(format!("{}", error), "S3 MRAP does not support S3 Accelerate")
433    }
434
435    /// MRAP explicitly disabled
436    #[test]
437    fn test_19() {
438        let params = crate::config::endpoint::Params::builder()
439            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
440            .region("us-east-1".to_string())
441            .disable_multi_region_access_points(true)
442            .use_fips(false)
443            .use_dual_stack(false)
444            .accelerate(false)
445            .build()
446            .expect("invalid params");
447        let resolver = crate::config::endpoint::DefaultResolver::new();
448        let endpoint = resolver.resolve_endpoint(&params);
449        let error =
450            endpoint.expect_err("expected error: Invalid configuration: Multi-Region Access Point ARNs are disabled. [MRAP explicitly disabled]");
451        assert_eq!(
452            format!("{}", error),
453            "Invalid configuration: Multi-Region Access Point ARNs are disabled."
454        )
455    }
456
457    /// Dual-stack endpoint with path-style forced
458    #[test]
459    fn test_20() {
460        let params = crate::config::endpoint::Params::builder()
461            .bucket("bucketname".to_string())
462            .region("us-west-2".to_string())
463            .force_path_style(true)
464            .use_fips(false)
465            .accelerate(false)
466            .use_dual_stack(true)
467            .build()
468            .expect("invalid params");
469        let resolver = crate::config::endpoint::DefaultResolver::new();
470        let endpoint = resolver.resolve_endpoint(&params);
471        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/bucketname");
472        assert_eq!(
473            endpoint,
474            ::aws_smithy_types::endpoint::Endpoint::builder()
475                .url("https://s3.dualstack.us-west-2.amazonaws.com/bucketname")
476                .property(
477                    "authSchemes",
478                    vec![{
479                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
480                        out.insert("name".to_string(), "sigv4".to_string().into());
481                        out.insert("signingName".to_string(), "s3".to_string().into());
482                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
483                        out.insert("disableDoubleEncoding".to_string(), true.into());
484                        out
485                    }
486                    .into()]
487                )
488                .build()
489        );
490    }
491
492    /// Dual-stack endpoint + SDK::Host is error
493    #[test]
494    fn test_21() {
495        let params = crate::config::endpoint::Params::builder()
496            .bucket("bucketname".to_string())
497            .region("us-west-2".to_string())
498            .force_path_style(true)
499            .use_fips(false)
500            .accelerate(false)
501            .use_dual_stack(true)
502            .endpoint("https://abc.com".to_string())
503            .build()
504            .expect("invalid params");
505        let resolver = crate::config::endpoint::DefaultResolver::new();
506        let endpoint = resolver.resolve_endpoint(&params);
507        let error = endpoint
508            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [Dual-stack endpoint + SDK::Host is error]");
509        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
510    }
511
512    /// path style + ARN bucket
513    #[test]
514    fn test_22() {
515        let params = crate::config::endpoint::Params::builder()
516            .accelerate(false)
517            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
518            .force_path_style(true)
519            .region("us-west-2".to_string())
520            .use_dual_stack(false)
521            .use_fips(false)
522            .build()
523            .expect("invalid params");
524        let resolver = crate::config::endpoint::DefaultResolver::new();
525        let endpoint = resolver.resolve_endpoint(&params);
526        let error = endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + ARN bucket]");
527        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
528    }
529
530    /// implicit path style bucket + dualstack
531    #[test]
532    fn test_23() {
533        let params = crate::config::endpoint::Params::builder()
534            .accelerate(false)
535            .bucket("99_ab".to_string())
536            .region("us-west-2".to_string())
537            .use_dual_stack(true)
538            .use_fips(false)
539            .build()
540            .expect("invalid params");
541        let resolver = crate::config::endpoint::DefaultResolver::new();
542        let endpoint = resolver.resolve_endpoint(&params);
543        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/99_ab");
544        assert_eq!(
545            endpoint,
546            ::aws_smithy_types::endpoint::Endpoint::builder()
547                .url("https://s3.dualstack.us-west-2.amazonaws.com/99_ab")
548                .property(
549                    "authSchemes",
550                    vec![{
551                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
552                        out.insert("name".to_string(), "sigv4".to_string().into());
553                        out.insert("signingName".to_string(), "s3".to_string().into());
554                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
555                        out.insert("disableDoubleEncoding".to_string(), true.into());
556                        out
557                    }
558                    .into()]
559                )
560                .build()
561        );
562    }
563
564    /// implicit path style bucket + dualstack
565    #[test]
566    fn test_24() {
567        let params = crate::config::endpoint::Params::builder()
568            .accelerate(false)
569            .bucket("99_ab".to_string())
570            .region("us-west-2".to_string())
571            .use_dual_stack(true)
572            .use_fips(false)
573            .endpoint("http://abc.com".to_string())
574            .build()
575            .expect("invalid params");
576        let resolver = crate::config::endpoint::DefaultResolver::new();
577        let endpoint = resolver.resolve_endpoint(&params);
578        let error = endpoint
579            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [implicit path style bucket + dualstack]");
580        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
581    }
582
583    /// don't allow URL injections in the bucket
584    #[test]
585    fn test_25() {
586        let params = crate::config::endpoint::Params::builder()
587            .bucket("example.com#".to_string())
588            .region("us-west-2".to_string())
589            .use_dual_stack(false)
590            .use_fips(false)
591            .accelerate(false)
592            .build()
593            .expect("invalid params");
594        let resolver = crate::config::endpoint::DefaultResolver::new();
595        let endpoint = resolver.resolve_endpoint(&params);
596        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/example.com%23");
597        assert_eq!(
598            endpoint,
599            ::aws_smithy_types::endpoint::Endpoint::builder()
600                .url("https://s3.us-west-2.amazonaws.com/example.com%23")
601                .property(
602                    "authSchemes",
603                    vec![{
604                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
605                        out.insert("name".to_string(), "sigv4".to_string().into());
606                        out.insert("signingName".to_string(), "s3".to_string().into());
607                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
608                        out.insert("disableDoubleEncoding".to_string(), true.into());
609                        out
610                    }
611                    .into()]
612                )
613                .build()
614        );
615    }
616
617    /// URI encode bucket names in the path
618    #[test]
619    fn test_26() {
620        let params = crate::config::endpoint::Params::builder()
621            .bucket("bucket name".to_string())
622            .region("us-west-2".to_string())
623            .use_dual_stack(false)
624            .use_fips(false)
625            .accelerate(false)
626            .build()
627            .expect("invalid params");
628        let resolver = crate::config::endpoint::DefaultResolver::new();
629        let endpoint = resolver.resolve_endpoint(&params);
630        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket%20name");
631        assert_eq!(
632            endpoint,
633            ::aws_smithy_types::endpoint::Endpoint::builder()
634                .url("https://s3.us-west-2.amazonaws.com/bucket%20name")
635                .property(
636                    "authSchemes",
637                    vec![{
638                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
639                        out.insert("name".to_string(), "sigv4".to_string().into());
640                        out.insert("signingName".to_string(), "s3".to_string().into());
641                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
642                        out.insert("disableDoubleEncoding".to_string(), true.into());
643                        out
644                    }
645                    .into()]
646                )
647                .build()
648        );
649    }
650
651    /// scheme is respected
652    #[test]
653    fn test_27() {
654        let params = crate::config::endpoint::Params::builder()
655            .accelerate(false)
656            .bucket("99_ab".to_string())
657            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
658            .region("af-south-1".to_string())
659            .use_dual_stack(false)
660            .use_fips(false)
661            .build()
662            .expect("invalid params");
663        let resolver = crate::config::endpoint::DefaultResolver::new();
664        let endpoint = resolver.resolve_endpoint(&params);
665        let endpoint = endpoint.expect("Expected valid endpoint: http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab");
666        assert_eq!(
667            endpoint,
668            ::aws_smithy_types::endpoint::Endpoint::builder()
669                .url("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab")
670                .property(
671                    "authSchemes",
672                    vec![{
673                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
674                        out.insert("name".to_string(), "sigv4".to_string().into());
675                        out.insert("signingName".to_string(), "s3".to_string().into());
676                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
677                        out.insert("disableDoubleEncoding".to_string(), true.into());
678                        out
679                    }
680                    .into()]
681                )
682                .build()
683        );
684    }
685
686    /// scheme is respected (virtual addressing)
687    #[test]
688    fn test_28() {
689        let params = crate::config::endpoint::Params::builder()
690            .accelerate(false)
691            .bucket("bucketname".to_string())
692            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo".to_string())
693            .region("af-south-1".to_string())
694            .use_dual_stack(false)
695            .use_fips(false)
696            .build()
697            .expect("invalid params");
698        let resolver = crate::config::endpoint::DefaultResolver::new();
699        let endpoint = resolver.resolve_endpoint(&params);
700        let endpoint = endpoint.expect("Expected valid endpoint: http://bucketname.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo");
701        assert_eq!(
702            endpoint,
703            ::aws_smithy_types::endpoint::Endpoint::builder()
704                .url("http://bucketname.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo")
705                .property(
706                    "authSchemes",
707                    vec![{
708                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
709                        out.insert("name".to_string(), "sigv4".to_string().into());
710                        out.insert("signingName".to_string(), "s3".to_string().into());
711                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
712                        out.insert("disableDoubleEncoding".to_string(), true.into());
713                        out
714                    }
715                    .into()]
716                )
717                .build()
718        );
719    }
720
721    /// path style + implicit private link
722    #[test]
723    fn test_29() {
724        let params = crate::config::endpoint::Params::builder()
725            .accelerate(false)
726            .bucket("99_ab".to_string())
727            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
728            .region("af-south-1".to_string())
729            .use_dual_stack(false)
730            .use_fips(false)
731            .build()
732            .expect("invalid params");
733        let resolver = crate::config::endpoint::DefaultResolver::new();
734        let endpoint = resolver.resolve_endpoint(&params);
735        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab");
736        assert_eq!(
737            endpoint,
738            ::aws_smithy_types::endpoint::Endpoint::builder()
739                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab")
740                .property(
741                    "authSchemes",
742                    vec![{
743                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
744                        out.insert("name".to_string(), "sigv4".to_string().into());
745                        out.insert("signingName".to_string(), "s3".to_string().into());
746                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
747                        out.insert("disableDoubleEncoding".to_string(), true.into());
748                        out
749                    }
750                    .into()]
751                )
752                .build()
753        );
754    }
755
756    /// invalid Endpoint override
757    #[test]
758    fn test_30() {
759        let params = crate::config::endpoint::Params::builder()
760            .accelerate(false)
761            .bucket("bucketname".to_string())
762            .endpoint("abcde://nota#url".to_string())
763            .region("af-south-1".to_string())
764            .use_dual_stack(false)
765            .use_fips(false)
766            .build()
767            .expect("invalid params");
768        let resolver = crate::config::endpoint::DefaultResolver::new();
769        let endpoint = resolver.resolve_endpoint(&params);
770        let error = endpoint.expect_err("expected error: Custom endpoint `abcde://nota#url` was not a valid URI [invalid Endpoint override]");
771        assert_eq!(format!("{}", error), "Custom endpoint `abcde://nota#url` was not a valid URI")
772    }
773
774    /// using an IPv4 address forces path style
775    #[test]
776    fn test_31() {
777        let params = crate::config::endpoint::Params::builder()
778            .accelerate(false)
779            .bucket("bucketname".to_string())
780            .endpoint("https://123.123.0.1".to_string())
781            .region("af-south-1".to_string())
782            .use_dual_stack(false)
783            .use_fips(false)
784            .build()
785            .expect("invalid params");
786        let resolver = crate::config::endpoint::DefaultResolver::new();
787        let endpoint = resolver.resolve_endpoint(&params);
788        let endpoint = endpoint.expect("Expected valid endpoint: https://123.123.0.1/bucketname");
789        assert_eq!(
790            endpoint,
791            ::aws_smithy_types::endpoint::Endpoint::builder()
792                .url("https://123.123.0.1/bucketname")
793                .property(
794                    "authSchemes",
795                    vec![{
796                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
797                        out.insert("name".to_string(), "sigv4".to_string().into());
798                        out.insert("signingName".to_string(), "s3".to_string().into());
799                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
800                        out.insert("disableDoubleEncoding".to_string(), true.into());
801                        out
802                    }
803                    .into()]
804                )
805                .build()
806        );
807    }
808
809    /// vanilla access point arn with region mismatch and UseArnRegion=false
810    #[test]
811    fn test_32() {
812        let params = crate::config::endpoint::Params::builder()
813            .accelerate(false)
814            .bucket("arn:aws:s3:us-east-1:123456789012:accesspoint:myendpoint".to_string())
815            .force_path_style(false)
816            .use_arn_region(false)
817            .region("us-west-2".to_string())
818            .use_dual_stack(false)
819            .use_fips(false)
820            .build()
821            .expect("invalid params");
822        let resolver = crate::config::endpoint::DefaultResolver::new();
823        let endpoint = resolver.resolve_endpoint(&params);
824        let error = endpoint.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false` [vanilla access point arn with region mismatch and UseArnRegion=false]");
825        assert_eq!(
826            format!("{}", error),
827            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
828        )
829    }
830
831    /// vanilla access point arn with region mismatch and UseArnRegion unset
832    #[test]
833    fn test_33() {
834        let params = crate::config::endpoint::Params::builder()
835            .accelerate(false)
836            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
837            .force_path_style(false)
838            .region("us-east-1".to_string())
839            .use_dual_stack(false)
840            .use_fips(false)
841            .build()
842            .expect("invalid params");
843        let resolver = crate::config::endpoint::DefaultResolver::new();
844        let endpoint = resolver.resolve_endpoint(&params);
845        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
846        assert_eq!(
847            endpoint,
848            ::aws_smithy_types::endpoint::Endpoint::builder()
849                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
850                .property(
851                    "authSchemes",
852                    vec![{
853                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
854                        out.insert("name".to_string(), "sigv4".to_string().into());
855                        out.insert("signingName".to_string(), "s3".to_string().into());
856                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
857                        out.insert("disableDoubleEncoding".to_string(), true.into());
858                        out
859                    }
860                    .into()]
861                )
862                .build()
863        );
864    }
865
866    /// vanilla access point arn with region mismatch and UseArnRegion=true
867    #[test]
868    fn test_34() {
869        let params = crate::config::endpoint::Params::builder()
870            .accelerate(false)
871            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
872            .force_path_style(false)
873            .use_arn_region(true)
874            .region("us-east-1".to_string())
875            .use_dual_stack(false)
876            .use_fips(false)
877            .build()
878            .expect("invalid params");
879        let resolver = crate::config::endpoint::DefaultResolver::new();
880        let endpoint = resolver.resolve_endpoint(&params);
881        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
882        assert_eq!(
883            endpoint,
884            ::aws_smithy_types::endpoint::Endpoint::builder()
885                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
886                .property(
887                    "authSchemes",
888                    vec![{
889                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
890                        out.insert("name".to_string(), "sigv4".to_string().into());
891                        out.insert("signingName".to_string(), "s3".to_string().into());
892                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
893                        out.insert("disableDoubleEncoding".to_string(), true.into());
894                        out
895                    }
896                    .into()]
897                )
898                .build()
899        );
900    }
901
902    /// subdomains are not allowed in virtual buckets
903    #[test]
904    fn test_35() {
905        let params = crate::config::endpoint::Params::builder()
906            .bucket("bucket.name".to_string())
907            .region("us-east-1".to_string())
908            .build()
909            .expect("invalid params");
910        let resolver = crate::config::endpoint::DefaultResolver::new();
911        let endpoint = resolver.resolve_endpoint(&params);
912        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/bucket.name");
913        assert_eq!(
914            endpoint,
915            ::aws_smithy_types::endpoint::Endpoint::builder()
916                .url("https://s3.us-east-1.amazonaws.com/bucket.name")
917                .property(
918                    "authSchemes",
919                    vec![{
920                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
921                        out.insert("name".to_string(), "sigv4".to_string().into());
922                        out.insert("signingName".to_string(), "s3".to_string().into());
923                        out.insert("disableDoubleEncoding".to_string(), true.into());
924                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
925                        out
926                    }
927                    .into()]
928                )
929                .build()
930        );
931    }
932
933    /// bucket names with 3 characters are allowed in virtual buckets
934    #[test]
935    fn test_36() {
936        let params = crate::config::endpoint::Params::builder()
937            .bucket("aaa".to_string())
938            .region("us-east-1".to_string())
939            .build()
940            .expect("invalid params");
941        let resolver = crate::config::endpoint::DefaultResolver::new();
942        let endpoint = resolver.resolve_endpoint(&params);
943        let endpoint = endpoint.expect("Expected valid endpoint: https://aaa.s3.us-east-1.amazonaws.com");
944        assert_eq!(
945            endpoint,
946            ::aws_smithy_types::endpoint::Endpoint::builder()
947                .url("https://aaa.s3.us-east-1.amazonaws.com")
948                .property(
949                    "authSchemes",
950                    vec![{
951                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
952                        out.insert("name".to_string(), "sigv4".to_string().into());
953                        out.insert("signingName".to_string(), "s3".to_string().into());
954                        out.insert("disableDoubleEncoding".to_string(), true.into());
955                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
956                        out
957                    }
958                    .into()]
959                )
960                .build()
961        );
962    }
963
964    /// bucket names with fewer than 3 characters are not allowed in virtual host
965    #[test]
966    fn test_37() {
967        let params = crate::config::endpoint::Params::builder()
968            .bucket("aa".to_string())
969            .region("us-east-1".to_string())
970            .build()
971            .expect("invalid params");
972        let resolver = crate::config::endpoint::DefaultResolver::new();
973        let endpoint = resolver.resolve_endpoint(&params);
974        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/aa");
975        assert_eq!(
976            endpoint,
977            ::aws_smithy_types::endpoint::Endpoint::builder()
978                .url("https://s3.us-east-1.amazonaws.com/aa")
979                .property(
980                    "authSchemes",
981                    vec![{
982                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
983                        out.insert("name".to_string(), "sigv4".to_string().into());
984                        out.insert("signingName".to_string(), "s3".to_string().into());
985                        out.insert("disableDoubleEncoding".to_string(), true.into());
986                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
987                        out
988                    }
989                    .into()]
990                )
991                .build()
992        );
993    }
994
995    /// bucket names with uppercase characters are not allowed in virtual host
996    #[test]
997    fn test_38() {
998        let params = crate::config::endpoint::Params::builder()
999            .bucket("BucketName".to_string())
1000            .region("us-east-1".to_string())
1001            .build()
1002            .expect("invalid params");
1003        let resolver = crate::config::endpoint::DefaultResolver::new();
1004        let endpoint = resolver.resolve_endpoint(&params);
1005        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/BucketName");
1006        assert_eq!(
1007            endpoint,
1008            ::aws_smithy_types::endpoint::Endpoint::builder()
1009                .url("https://s3.us-east-1.amazonaws.com/BucketName")
1010                .property(
1011                    "authSchemes",
1012                    vec![{
1013                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1014                        out.insert("name".to_string(), "sigv4".to_string().into());
1015                        out.insert("signingName".to_string(), "s3".to_string().into());
1016                        out.insert("disableDoubleEncoding".to_string(), true.into());
1017                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1018                        out
1019                    }
1020                    .into()]
1021                )
1022                .build()
1023        );
1024    }
1025
1026    /// subdomains are allowed in virtual buckets on http endpoints
1027    #[test]
1028    fn test_39() {
1029        let params = crate::config::endpoint::Params::builder()
1030            .bucket("bucket.name".to_string())
1031            .region("us-east-1".to_string())
1032            .endpoint("http://example.com".to_string())
1033            .build()
1034            .expect("invalid params");
1035        let resolver = crate::config::endpoint::DefaultResolver::new();
1036        let endpoint = resolver.resolve_endpoint(&params);
1037        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket.name.example.com");
1038        assert_eq!(
1039            endpoint,
1040            ::aws_smithy_types::endpoint::Endpoint::builder()
1041                .url("http://bucket.name.example.com")
1042                .property(
1043                    "authSchemes",
1044                    vec![{
1045                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1046                        out.insert("name".to_string(), "sigv4".to_string().into());
1047                        out.insert("signingName".to_string(), "s3".to_string().into());
1048                        out.insert("disableDoubleEncoding".to_string(), true.into());
1049                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1050                        out
1051                    }
1052                    .into()]
1053                )
1054                .build()
1055        );
1056    }
1057
1058    /// no region set
1059    #[test]
1060    fn test_40() {
1061        let params = crate::config::endpoint::Params::builder()
1062            .bucket("bucket-name".to_string())
1063            .build()
1064            .expect("invalid params");
1065        let resolver = crate::config::endpoint::DefaultResolver::new();
1066        let endpoint = resolver.resolve_endpoint(&params);
1067        let error = endpoint.expect_err("expected error: A region must be set when sending requests to S3. [no region set]");
1068        assert_eq!(format!("{}", error), "A region must be set when sending requests to S3.")
1069    }
1070
1071    /// UseGlobalEndpoints=true, region=us-east-1 uses the global endpoint
1072    #[test]
1073    fn test_41() {
1074        let params = crate::config::endpoint::Params::builder()
1075            .region("us-east-1".to_string())
1076            .use_global_endpoint(true)
1077            .use_fips(false)
1078            .use_dual_stack(false)
1079            .accelerate(false)
1080            .build()
1081            .expect("invalid params");
1082        let resolver = crate::config::endpoint::DefaultResolver::new();
1083        let endpoint = resolver.resolve_endpoint(&params);
1084        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1085        assert_eq!(
1086            endpoint,
1087            ::aws_smithy_types::endpoint::Endpoint::builder()
1088                .url("https://s3.amazonaws.com")
1089                .property(
1090                    "authSchemes",
1091                    vec![{
1092                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1093                        out.insert("name".to_string(), "sigv4".to_string().into());
1094                        out.insert("signingName".to_string(), "s3".to_string().into());
1095                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1096                        out.insert("disableDoubleEncoding".to_string(), true.into());
1097                        out
1098                    }
1099                    .into()]
1100                )
1101                .build()
1102        );
1103    }
1104
1105    /// UseGlobalEndpoints=true, region=us-west-2 uses the regional endpoint
1106    #[test]
1107    fn test_42() {
1108        let params = crate::config::endpoint::Params::builder()
1109            .region("us-west-2".to_string())
1110            .use_global_endpoint(true)
1111            .use_fips(false)
1112            .use_dual_stack(false)
1113            .accelerate(false)
1114            .build()
1115            .expect("invalid params");
1116        let resolver = crate::config::endpoint::DefaultResolver::new();
1117        let endpoint = resolver.resolve_endpoint(&params);
1118        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com");
1119        assert_eq!(
1120            endpoint,
1121            ::aws_smithy_types::endpoint::Endpoint::builder()
1122                .url("https://s3.us-west-2.amazonaws.com")
1123                .property(
1124                    "authSchemes",
1125                    vec![{
1126                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1127                        out.insert("name".to_string(), "sigv4".to_string().into());
1128                        out.insert("signingName".to_string(), "s3".to_string().into());
1129                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
1130                        out.insert("disableDoubleEncoding".to_string(), true.into());
1131                        out
1132                    }
1133                    .into()]
1134                )
1135                .build()
1136        );
1137    }
1138
1139    /// UseGlobalEndpoints=true, region=cn-north-1 uses the regional endpoint
1140    #[test]
1141    fn test_43() {
1142        let params = crate::config::endpoint::Params::builder()
1143            .region("cn-north-1".to_string())
1144            .use_global_endpoint(true)
1145            .use_fips(false)
1146            .use_dual_stack(false)
1147            .accelerate(false)
1148            .build()
1149            .expect("invalid params");
1150        let resolver = crate::config::endpoint::DefaultResolver::new();
1151        let endpoint = resolver.resolve_endpoint(&params);
1152        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn");
1153        assert_eq!(
1154            endpoint,
1155            ::aws_smithy_types::endpoint::Endpoint::builder()
1156                .url("https://s3.cn-north-1.amazonaws.com.cn")
1157                .property(
1158                    "authSchemes",
1159                    vec![{
1160                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1161                        out.insert("name".to_string(), "sigv4".to_string().into());
1162                        out.insert("signingName".to_string(), "s3".to_string().into());
1163                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
1164                        out.insert("disableDoubleEncoding".to_string(), true.into());
1165                        out
1166                    }
1167                    .into()]
1168                )
1169                .build()
1170        );
1171    }
1172
1173    /// UseGlobalEndpoints=true, region=us-east-1, fips=true uses the regional endpoint with fips
1174    #[test]
1175    fn test_44() {
1176        let params = crate::config::endpoint::Params::builder()
1177            .region("us-east-1".to_string())
1178            .use_global_endpoint(true)
1179            .use_fips(true)
1180            .use_dual_stack(false)
1181            .accelerate(false)
1182            .build()
1183            .expect("invalid params");
1184        let resolver = crate::config::endpoint::DefaultResolver::new();
1185        let endpoint = resolver.resolve_endpoint(&params);
1186        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com");
1187        assert_eq!(
1188            endpoint,
1189            ::aws_smithy_types::endpoint::Endpoint::builder()
1190                .url("https://s3-fips.us-east-1.amazonaws.com")
1191                .property(
1192                    "authSchemes",
1193                    vec![{
1194                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1195                        out.insert("name".to_string(), "sigv4".to_string().into());
1196                        out.insert("signingName".to_string(), "s3".to_string().into());
1197                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1198                        out.insert("disableDoubleEncoding".to_string(), true.into());
1199                        out
1200                    }
1201                    .into()]
1202                )
1203                .build()
1204        );
1205    }
1206
1207    /// UseGlobalEndpoints=true, region=us-east-1, dualstack=true uses the regional endpoint with dualstack
1208    #[test]
1209    fn test_45() {
1210        let params = crate::config::endpoint::Params::builder()
1211            .region("us-east-1".to_string())
1212            .use_global_endpoint(true)
1213            .use_fips(false)
1214            .use_dual_stack(true)
1215            .accelerate(false)
1216            .build()
1217            .expect("invalid params");
1218        let resolver = crate::config::endpoint::DefaultResolver::new();
1219        let endpoint = resolver.resolve_endpoint(&params);
1220        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com");
1221        assert_eq!(
1222            endpoint,
1223            ::aws_smithy_types::endpoint::Endpoint::builder()
1224                .url("https://s3.dualstack.us-east-1.amazonaws.com")
1225                .property(
1226                    "authSchemes",
1227                    vec![{
1228                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1229                        out.insert("name".to_string(), "sigv4".to_string().into());
1230                        out.insert("signingName".to_string(), "s3".to_string().into());
1231                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1232                        out.insert("disableDoubleEncoding".to_string(), true.into());
1233                        out
1234                    }
1235                    .into()]
1236                )
1237                .build()
1238        );
1239    }
1240
1241    /// UseGlobalEndpoints=true, region=us-east-1, dualstack and fips uses the regional endpoint with fips/dualstack
1242    #[test]
1243    fn test_46() {
1244        let params = crate::config::endpoint::Params::builder()
1245            .region("us-east-1".to_string())
1246            .use_global_endpoint(true)
1247            .use_fips(true)
1248            .use_dual_stack(true)
1249            .accelerate(false)
1250            .build()
1251            .expect("invalid params");
1252        let resolver = crate::config::endpoint::DefaultResolver::new();
1253        let endpoint = resolver.resolve_endpoint(&params);
1254        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com");
1255        assert_eq!(
1256            endpoint,
1257            ::aws_smithy_types::endpoint::Endpoint::builder()
1258                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com")
1259                .property(
1260                    "authSchemes",
1261                    vec![{
1262                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1263                        out.insert("name".to_string(), "sigv4".to_string().into());
1264                        out.insert("signingName".to_string(), "s3".to_string().into());
1265                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1266                        out.insert("disableDoubleEncoding".to_string(), true.into());
1267                        out
1268                    }
1269                    .into()]
1270                )
1271                .build()
1272        );
1273    }
1274
1275    /// UseGlobalEndpoints=true, region=us-east-1 with custom endpoint, uses custom
1276    #[test]
1277    fn test_47() {
1278        let params = crate::config::endpoint::Params::builder()
1279            .region("us-east-1".to_string())
1280            .endpoint("https://example.com".to_string())
1281            .use_global_endpoint(true)
1282            .use_fips(false)
1283            .use_dual_stack(false)
1284            .accelerate(false)
1285            .build()
1286            .expect("invalid params");
1287        let resolver = crate::config::endpoint::DefaultResolver::new();
1288        let endpoint = resolver.resolve_endpoint(&params);
1289        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1290        assert_eq!(
1291            endpoint,
1292            ::aws_smithy_types::endpoint::Endpoint::builder()
1293                .url("https://example.com")
1294                .property(
1295                    "authSchemes",
1296                    vec![{
1297                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1298                        out.insert("name".to_string(), "sigv4".to_string().into());
1299                        out.insert("signingName".to_string(), "s3".to_string().into());
1300                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1301                        out.insert("disableDoubleEncoding".to_string(), true.into());
1302                        out
1303                    }
1304                    .into()]
1305                )
1306                .build()
1307        );
1308    }
1309
1310    /// UseGlobalEndpoints=true, region=us-west-2 with custom endpoint, uses custom
1311    #[test]
1312    fn test_48() {
1313        let params = crate::config::endpoint::Params::builder()
1314            .region("us-west-2".to_string())
1315            .endpoint("https://example.com".to_string())
1316            .use_global_endpoint(true)
1317            .use_fips(false)
1318            .use_dual_stack(false)
1319            .accelerate(false)
1320            .build()
1321            .expect("invalid params");
1322        let resolver = crate::config::endpoint::DefaultResolver::new();
1323        let endpoint = resolver.resolve_endpoint(&params);
1324        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1325        assert_eq!(
1326            endpoint,
1327            ::aws_smithy_types::endpoint::Endpoint::builder()
1328                .url("https://example.com")
1329                .property(
1330                    "authSchemes",
1331                    vec![{
1332                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1333                        out.insert("name".to_string(), "sigv4".to_string().into());
1334                        out.insert("signingName".to_string(), "s3".to_string().into());
1335                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
1336                        out.insert("disableDoubleEncoding".to_string(), true.into());
1337                        out
1338                    }
1339                    .into()]
1340                )
1341                .build()
1342        );
1343    }
1344
1345    /// UseGlobalEndpoints=true, region=us-east-1 with accelerate on non bucket case uses the global endpoint and ignores accelerate
1346    #[test]
1347    fn test_49() {
1348        let params = crate::config::endpoint::Params::builder()
1349            .region("us-east-1".to_string())
1350            .use_global_endpoint(true)
1351            .use_fips(false)
1352            .use_dual_stack(false)
1353            .accelerate(true)
1354            .build()
1355            .expect("invalid params");
1356        let resolver = crate::config::endpoint::DefaultResolver::new();
1357        let endpoint = resolver.resolve_endpoint(&params);
1358        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1359        assert_eq!(
1360            endpoint,
1361            ::aws_smithy_types::endpoint::Endpoint::builder()
1362                .url("https://s3.amazonaws.com")
1363                .property(
1364                    "authSchemes",
1365                    vec![{
1366                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1367                        out.insert("name".to_string(), "sigv4".to_string().into());
1368                        out.insert("signingName".to_string(), "s3".to_string().into());
1369                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1370                        out.insert("disableDoubleEncoding".to_string(), true.into());
1371                        out
1372                    }
1373                    .into()]
1374                )
1375                .build()
1376        );
1377    }
1378
1379    /// aws-global region uses the global endpoint
1380    #[test]
1381    fn test_50() {
1382        let params = crate::config::endpoint::Params::builder()
1383            .region("aws-global".to_string())
1384            .use_fips(false)
1385            .use_dual_stack(false)
1386            .accelerate(false)
1387            .build()
1388            .expect("invalid params");
1389        let resolver = crate::config::endpoint::DefaultResolver::new();
1390        let endpoint = resolver.resolve_endpoint(&params);
1391        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1392        assert_eq!(
1393            endpoint,
1394            ::aws_smithy_types::endpoint::Endpoint::builder()
1395                .url("https://s3.amazonaws.com")
1396                .property(
1397                    "authSchemes",
1398                    vec![{
1399                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1400                        out.insert("name".to_string(), "sigv4".to_string().into());
1401                        out.insert("signingName".to_string(), "s3".to_string().into());
1402                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1403                        out.insert("disableDoubleEncoding".to_string(), true.into());
1404                        out
1405                    }
1406                    .into()]
1407                )
1408                .build()
1409        );
1410    }
1411
1412    /// aws-global region with fips uses the regional endpoint
1413    #[test]
1414    fn test_51() {
1415        let params = crate::config::endpoint::Params::builder()
1416            .region("aws-global".to_string())
1417            .use_fips(true)
1418            .use_dual_stack(false)
1419            .accelerate(false)
1420            .build()
1421            .expect("invalid params");
1422        let resolver = crate::config::endpoint::DefaultResolver::new();
1423        let endpoint = resolver.resolve_endpoint(&params);
1424        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com");
1425        assert_eq!(
1426            endpoint,
1427            ::aws_smithy_types::endpoint::Endpoint::builder()
1428                .url("https://s3-fips.us-east-1.amazonaws.com")
1429                .property(
1430                    "authSchemes",
1431                    vec![{
1432                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1433                        out.insert("name".to_string(), "sigv4".to_string().into());
1434                        out.insert("signingName".to_string(), "s3".to_string().into());
1435                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1436                        out.insert("disableDoubleEncoding".to_string(), true.into());
1437                        out
1438                    }
1439                    .into()]
1440                )
1441                .build()
1442        );
1443    }
1444
1445    /// aws-global region with dualstack uses the regional endpoint
1446    #[test]
1447    fn test_52() {
1448        let params = crate::config::endpoint::Params::builder()
1449            .region("aws-global".to_string())
1450            .use_fips(false)
1451            .use_dual_stack(true)
1452            .accelerate(false)
1453            .build()
1454            .expect("invalid params");
1455        let resolver = crate::config::endpoint::DefaultResolver::new();
1456        let endpoint = resolver.resolve_endpoint(&params);
1457        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com");
1458        assert_eq!(
1459            endpoint,
1460            ::aws_smithy_types::endpoint::Endpoint::builder()
1461                .url("https://s3.dualstack.us-east-1.amazonaws.com")
1462                .property(
1463                    "authSchemes",
1464                    vec![{
1465                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1466                        out.insert("name".to_string(), "sigv4".to_string().into());
1467                        out.insert("signingName".to_string(), "s3".to_string().into());
1468                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1469                        out.insert("disableDoubleEncoding".to_string(), true.into());
1470                        out
1471                    }
1472                    .into()]
1473                )
1474                .build()
1475        );
1476    }
1477
1478    /// aws-global region with fips and dualstack uses the regional endpoint
1479    #[test]
1480    fn test_53() {
1481        let params = crate::config::endpoint::Params::builder()
1482            .region("aws-global".to_string())
1483            .use_fips(true)
1484            .use_dual_stack(true)
1485            .accelerate(false)
1486            .build()
1487            .expect("invalid params");
1488        let resolver = crate::config::endpoint::DefaultResolver::new();
1489        let endpoint = resolver.resolve_endpoint(&params);
1490        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com");
1491        assert_eq!(
1492            endpoint,
1493            ::aws_smithy_types::endpoint::Endpoint::builder()
1494                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com")
1495                .property(
1496                    "authSchemes",
1497                    vec![{
1498                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1499                        out.insert("name".to_string(), "sigv4".to_string().into());
1500                        out.insert("signingName".to_string(), "s3".to_string().into());
1501                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1502                        out.insert("disableDoubleEncoding".to_string(), true.into());
1503                        out
1504                    }
1505                    .into()]
1506                )
1507                .build()
1508        );
1509    }
1510
1511    /// aws-global region with accelerate on non-bucket case, uses global endpoint and ignores accelerate
1512    #[test]
1513    fn test_54() {
1514        let params = crate::config::endpoint::Params::builder()
1515            .region("aws-global".to_string())
1516            .use_fips(false)
1517            .use_dual_stack(false)
1518            .accelerate(true)
1519            .build()
1520            .expect("invalid params");
1521        let resolver = crate::config::endpoint::DefaultResolver::new();
1522        let endpoint = resolver.resolve_endpoint(&params);
1523        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1524        assert_eq!(
1525            endpoint,
1526            ::aws_smithy_types::endpoint::Endpoint::builder()
1527                .url("https://s3.amazonaws.com")
1528                .property(
1529                    "authSchemes",
1530                    vec![{
1531                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1532                        out.insert("name".to_string(), "sigv4".to_string().into());
1533                        out.insert("signingName".to_string(), "s3".to_string().into());
1534                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1535                        out.insert("disableDoubleEncoding".to_string(), true.into());
1536                        out
1537                    }
1538                    .into()]
1539                )
1540                .build()
1541        );
1542    }
1543
1544    /// aws-global region with custom endpoint, uses custom
1545    #[test]
1546    fn test_55() {
1547        let params = crate::config::endpoint::Params::builder()
1548            .region("aws-global".to_string())
1549            .endpoint("https://example.com".to_string())
1550            .use_global_endpoint(false)
1551            .use_fips(false)
1552            .use_dual_stack(false)
1553            .accelerate(false)
1554            .build()
1555            .expect("invalid params");
1556        let resolver = crate::config::endpoint::DefaultResolver::new();
1557        let endpoint = resolver.resolve_endpoint(&params);
1558        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1559        assert_eq!(
1560            endpoint,
1561            ::aws_smithy_types::endpoint::Endpoint::builder()
1562                .url("https://example.com")
1563                .property(
1564                    "authSchemes",
1565                    vec![{
1566                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1567                        out.insert("name".to_string(), "sigv4".to_string().into());
1568                        out.insert("signingName".to_string(), "s3".to_string().into());
1569                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1570                        out.insert("disableDoubleEncoding".to_string(), true.into());
1571                        out
1572                    }
1573                    .into()]
1574                )
1575                .build()
1576        );
1577    }
1578
1579    /// virtual addressing, aws-global region uses the global endpoint
1580    #[test]
1581    fn test_56() {
1582        let params = crate::config::endpoint::Params::builder()
1583            .region("aws-global".to_string())
1584            .bucket("bucket-name".to_string())
1585            .use_fips(false)
1586            .use_dual_stack(false)
1587            .accelerate(false)
1588            .build()
1589            .expect("invalid params");
1590        let resolver = crate::config::endpoint::DefaultResolver::new();
1591        let endpoint = resolver.resolve_endpoint(&params);
1592        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1593        assert_eq!(
1594            endpoint,
1595            ::aws_smithy_types::endpoint::Endpoint::builder()
1596                .url("https://bucket-name.s3.amazonaws.com")
1597                .property(
1598                    "authSchemes",
1599                    vec![{
1600                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1601                        out.insert("name".to_string(), "sigv4".to_string().into());
1602                        out.insert("signingName".to_string(), "s3".to_string().into());
1603                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1604                        out.insert("disableDoubleEncoding".to_string(), true.into());
1605                        out
1606                    }
1607                    .into()]
1608                )
1609                .build()
1610        );
1611    }
1612
1613    /// virtual addressing, aws-global region with Prefix, and Key uses the global endpoint. Prefix and Key parameters should not be used in endpoint evaluation.
1614    #[test]
1615    fn test_57() {
1616        let params = crate::config::endpoint::Params::builder()
1617            .region("aws-global".to_string())
1618            .bucket("bucket-name".to_string())
1619            .use_fips(false)
1620            .use_dual_stack(false)
1621            .accelerate(false)
1622            .prefix("prefix".to_string())
1623            .key("key".to_string())
1624            .build()
1625            .expect("invalid params");
1626        let resolver = crate::config::endpoint::DefaultResolver::new();
1627        let endpoint = resolver.resolve_endpoint(&params);
1628        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1629        assert_eq!(
1630            endpoint,
1631            ::aws_smithy_types::endpoint::Endpoint::builder()
1632                .url("https://bucket-name.s3.amazonaws.com")
1633                .property(
1634                    "authSchemes",
1635                    vec![{
1636                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1637                        out.insert("name".to_string(), "sigv4".to_string().into());
1638                        out.insert("signingName".to_string(), "s3".to_string().into());
1639                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1640                        out.insert("disableDoubleEncoding".to_string(), true.into());
1641                        out
1642                    }
1643                    .into()]
1644                )
1645                .build()
1646        );
1647    }
1648
1649    /// virtual addressing, aws-global region with Copy Source, and Key uses the global endpoint. Copy Source and Key parameters should not be used in endpoint evaluation.
1650    #[test]
1651    fn test_58() {
1652        let params = crate::config::endpoint::Params::builder()
1653            .region("aws-global".to_string())
1654            .bucket("bucket-name".to_string())
1655            .use_fips(false)
1656            .use_dual_stack(false)
1657            .accelerate(false)
1658            .copy_source("/copy/source".to_string())
1659            .key("key".to_string())
1660            .build()
1661            .expect("invalid params");
1662        let resolver = crate::config::endpoint::DefaultResolver::new();
1663        let endpoint = resolver.resolve_endpoint(&params);
1664        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1665        assert_eq!(
1666            endpoint,
1667            ::aws_smithy_types::endpoint::Endpoint::builder()
1668                .url("https://bucket-name.s3.amazonaws.com")
1669                .property(
1670                    "authSchemes",
1671                    vec![{
1672                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1673                        out.insert("name".to_string(), "sigv4".to_string().into());
1674                        out.insert("signingName".to_string(), "s3".to_string().into());
1675                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1676                        out.insert("disableDoubleEncoding".to_string(), true.into());
1677                        out
1678                    }
1679                    .into()]
1680                )
1681                .build()
1682        );
1683    }
1684
1685    /// virtual addressing, aws-global region with fips uses the regional fips endpoint
1686    #[test]
1687    fn test_59() {
1688        let params = crate::config::endpoint::Params::builder()
1689            .region("aws-global".to_string())
1690            .bucket("bucket-name".to_string())
1691            .use_fips(true)
1692            .use_dual_stack(false)
1693            .accelerate(false)
1694            .build()
1695            .expect("invalid params");
1696        let resolver = crate::config::endpoint::DefaultResolver::new();
1697        let endpoint = resolver.resolve_endpoint(&params);
1698        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-east-1.amazonaws.com");
1699        assert_eq!(
1700            endpoint,
1701            ::aws_smithy_types::endpoint::Endpoint::builder()
1702                .url("https://bucket-name.s3-fips.us-east-1.amazonaws.com")
1703                .property(
1704                    "authSchemes",
1705                    vec![{
1706                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1707                        out.insert("name".to_string(), "sigv4".to_string().into());
1708                        out.insert("signingName".to_string(), "s3".to_string().into());
1709                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1710                        out.insert("disableDoubleEncoding".to_string(), true.into());
1711                        out
1712                    }
1713                    .into()]
1714                )
1715                .build()
1716        );
1717    }
1718
1719    /// virtual addressing, aws-global region with dualstack uses the regional dualstack endpoint
1720    #[test]
1721    fn test_60() {
1722        let params = crate::config::endpoint::Params::builder()
1723            .region("aws-global".to_string())
1724            .bucket("bucket-name".to_string())
1725            .use_fips(false)
1726            .use_dual_stack(true)
1727            .accelerate(false)
1728            .build()
1729            .expect("invalid params");
1730        let resolver = crate::config::endpoint::DefaultResolver::new();
1731        let endpoint = resolver.resolve_endpoint(&params);
1732        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-east-1.amazonaws.com");
1733        assert_eq!(
1734            endpoint,
1735            ::aws_smithy_types::endpoint::Endpoint::builder()
1736                .url("https://bucket-name.s3.dualstack.us-east-1.amazonaws.com")
1737                .property(
1738                    "authSchemes",
1739                    vec![{
1740                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1741                        out.insert("name".to_string(), "sigv4".to_string().into());
1742                        out.insert("signingName".to_string(), "s3".to_string().into());
1743                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1744                        out.insert("disableDoubleEncoding".to_string(), true.into());
1745                        out
1746                    }
1747                    .into()]
1748                )
1749                .build()
1750        );
1751    }
1752
1753    /// virtual addressing, aws-global region with fips/dualstack uses the regional fips/dualstack endpoint
1754    #[test]
1755    fn test_61() {
1756        let params = crate::config::endpoint::Params::builder()
1757            .region("aws-global".to_string())
1758            .bucket("bucket-name".to_string())
1759            .use_fips(true)
1760            .use_dual_stack(true)
1761            .accelerate(false)
1762            .build()
1763            .expect("invalid params");
1764        let resolver = crate::config::endpoint::DefaultResolver::new();
1765        let endpoint = resolver.resolve_endpoint(&params);
1766        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.us-east-1.amazonaws.com");
1767        assert_eq!(
1768            endpoint,
1769            ::aws_smithy_types::endpoint::Endpoint::builder()
1770                .url("https://bucket-name.s3-fips.dualstack.us-east-1.amazonaws.com")
1771                .property(
1772                    "authSchemes",
1773                    vec![{
1774                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1775                        out.insert("name".to_string(), "sigv4".to_string().into());
1776                        out.insert("signingName".to_string(), "s3".to_string().into());
1777                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1778                        out.insert("disableDoubleEncoding".to_string(), true.into());
1779                        out
1780                    }
1781                    .into()]
1782                )
1783                .build()
1784        );
1785    }
1786
1787    /// virtual addressing, aws-global region with accelerate uses the global accelerate endpoint
1788    #[test]
1789    fn test_62() {
1790        let params = crate::config::endpoint::Params::builder()
1791            .region("aws-global".to_string())
1792            .bucket("bucket-name".to_string())
1793            .use_fips(false)
1794            .use_dual_stack(false)
1795            .accelerate(true)
1796            .build()
1797            .expect("invalid params");
1798        let resolver = crate::config::endpoint::DefaultResolver::new();
1799        let endpoint = resolver.resolve_endpoint(&params);
1800        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
1801        assert_eq!(
1802            endpoint,
1803            ::aws_smithy_types::endpoint::Endpoint::builder()
1804                .url("https://bucket-name.s3-accelerate.amazonaws.com")
1805                .property(
1806                    "authSchemes",
1807                    vec![{
1808                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1809                        out.insert("name".to_string(), "sigv4".to_string().into());
1810                        out.insert("signingName".to_string(), "s3".to_string().into());
1811                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1812                        out.insert("disableDoubleEncoding".to_string(), true.into());
1813                        out
1814                    }
1815                    .into()]
1816                )
1817                .build()
1818        );
1819    }
1820
1821    /// virtual addressing, aws-global region with custom endpoint
1822    #[test]
1823    fn test_63() {
1824        let params = crate::config::endpoint::Params::builder()
1825            .region("aws-global".to_string())
1826            .endpoint("https://example.com".to_string())
1827            .bucket("bucket-name".to_string())
1828            .use_fips(false)
1829            .use_dual_stack(false)
1830            .accelerate(false)
1831            .build()
1832            .expect("invalid params");
1833        let resolver = crate::config::endpoint::DefaultResolver::new();
1834        let endpoint = resolver.resolve_endpoint(&params);
1835        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.example.com");
1836        assert_eq!(
1837            endpoint,
1838            ::aws_smithy_types::endpoint::Endpoint::builder()
1839                .url("https://bucket-name.example.com")
1840                .property(
1841                    "authSchemes",
1842                    vec![{
1843                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1844                        out.insert("name".to_string(), "sigv4".to_string().into());
1845                        out.insert("signingName".to_string(), "s3".to_string().into());
1846                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1847                        out.insert("disableDoubleEncoding".to_string(), true.into());
1848                        out
1849                    }
1850                    .into()]
1851                )
1852                .build()
1853        );
1854    }
1855
1856    /// virtual addressing, UseGlobalEndpoint and us-east-1 region uses the global endpoint
1857    #[test]
1858    fn test_64() {
1859        let params = crate::config::endpoint::Params::builder()
1860            .region("us-east-1".to_string())
1861            .use_global_endpoint(true)
1862            .bucket("bucket-name".to_string())
1863            .use_fips(false)
1864            .use_dual_stack(false)
1865            .accelerate(false)
1866            .build()
1867            .expect("invalid params");
1868        let resolver = crate::config::endpoint::DefaultResolver::new();
1869        let endpoint = resolver.resolve_endpoint(&params);
1870        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1871        assert_eq!(
1872            endpoint,
1873            ::aws_smithy_types::endpoint::Endpoint::builder()
1874                .url("https://bucket-name.s3.amazonaws.com")
1875                .property(
1876                    "authSchemes",
1877                    vec![{
1878                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1879                        out.insert("name".to_string(), "sigv4".to_string().into());
1880                        out.insert("signingName".to_string(), "s3".to_string().into());
1881                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1882                        out.insert("disableDoubleEncoding".to_string(), true.into());
1883                        out
1884                    }
1885                    .into()]
1886                )
1887                .build()
1888        );
1889    }
1890
1891    /// virtual addressing, UseGlobalEndpoint and us-west-2 region uses the regional endpoint
1892    #[test]
1893    fn test_65() {
1894        let params = crate::config::endpoint::Params::builder()
1895            .region("us-west-2".to_string())
1896            .use_global_endpoint(true)
1897            .bucket("bucket-name".to_string())
1898            .use_fips(false)
1899            .use_dual_stack(false)
1900            .accelerate(false)
1901            .build()
1902            .expect("invalid params");
1903        let resolver = crate::config::endpoint::DefaultResolver::new();
1904        let endpoint = resolver.resolve_endpoint(&params);
1905        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.us-west-2.amazonaws.com");
1906        assert_eq!(
1907            endpoint,
1908            ::aws_smithy_types::endpoint::Endpoint::builder()
1909                .url("https://bucket-name.s3.us-west-2.amazonaws.com")
1910                .property(
1911                    "authSchemes",
1912                    vec![{
1913                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1914                        out.insert("name".to_string(), "sigv4".to_string().into());
1915                        out.insert("signingName".to_string(), "s3".to_string().into());
1916                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
1917                        out.insert("disableDoubleEncoding".to_string(), true.into());
1918                        out
1919                    }
1920                    .into()]
1921                )
1922                .build()
1923        );
1924    }
1925
1926    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and fips uses the regional fips endpoint
1927    #[test]
1928    fn test_66() {
1929        let params = crate::config::endpoint::Params::builder()
1930            .region("us-east-1".to_string())
1931            .use_global_endpoint(true)
1932            .bucket("bucket-name".to_string())
1933            .use_fips(true)
1934            .use_dual_stack(false)
1935            .accelerate(false)
1936            .build()
1937            .expect("invalid params");
1938        let resolver = crate::config::endpoint::DefaultResolver::new();
1939        let endpoint = resolver.resolve_endpoint(&params);
1940        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-east-1.amazonaws.com");
1941        assert_eq!(
1942            endpoint,
1943            ::aws_smithy_types::endpoint::Endpoint::builder()
1944                .url("https://bucket-name.s3-fips.us-east-1.amazonaws.com")
1945                .property(
1946                    "authSchemes",
1947                    vec![{
1948                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1949                        out.insert("name".to_string(), "sigv4".to_string().into());
1950                        out.insert("signingName".to_string(), "s3".to_string().into());
1951                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1952                        out.insert("disableDoubleEncoding".to_string(), true.into());
1953                        out
1954                    }
1955                    .into()]
1956                )
1957                .build()
1958        );
1959    }
1960
1961    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and dualstack uses the regional dualstack endpoint
1962    #[test]
1963    fn test_67() {
1964        let params = crate::config::endpoint::Params::builder()
1965            .region("us-east-1".to_string())
1966            .use_global_endpoint(true)
1967            .bucket("bucket-name".to_string())
1968            .use_fips(false)
1969            .use_dual_stack(true)
1970            .accelerate(false)
1971            .build()
1972            .expect("invalid params");
1973        let resolver = crate::config::endpoint::DefaultResolver::new();
1974        let endpoint = resolver.resolve_endpoint(&params);
1975        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-east-1.amazonaws.com");
1976        assert_eq!(
1977            endpoint,
1978            ::aws_smithy_types::endpoint::Endpoint::builder()
1979                .url("https://bucket-name.s3.dualstack.us-east-1.amazonaws.com")
1980                .property(
1981                    "authSchemes",
1982                    vec![{
1983                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1984                        out.insert("name".to_string(), "sigv4".to_string().into());
1985                        out.insert("signingName".to_string(), "s3".to_string().into());
1986                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1987                        out.insert("disableDoubleEncoding".to_string(), true.into());
1988                        out
1989                    }
1990                    .into()]
1991                )
1992                .build()
1993        );
1994    }
1995
1996    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and accelerate uses the global accelerate endpoint
1997    #[test]
1998    fn test_68() {
1999        let params = crate::config::endpoint::Params::builder()
2000            .region("us-east-1".to_string())
2001            .use_global_endpoint(true)
2002            .bucket("bucket-name".to_string())
2003            .use_fips(false)
2004            .use_dual_stack(false)
2005            .accelerate(true)
2006            .build()
2007            .expect("invalid params");
2008        let resolver = crate::config::endpoint::DefaultResolver::new();
2009        let endpoint = resolver.resolve_endpoint(&params);
2010        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
2011        assert_eq!(
2012            endpoint,
2013            ::aws_smithy_types::endpoint::Endpoint::builder()
2014                .url("https://bucket-name.s3-accelerate.amazonaws.com")
2015                .property(
2016                    "authSchemes",
2017                    vec![{
2018                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2019                        out.insert("name".to_string(), "sigv4".to_string().into());
2020                        out.insert("signingName".to_string(), "s3".to_string().into());
2021                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2022                        out.insert("disableDoubleEncoding".to_string(), true.into());
2023                        out
2024                    }
2025                    .into()]
2026                )
2027                .build()
2028        );
2029    }
2030
2031    /// virtual addressing, UseGlobalEndpoint and us-east-1 region with custom endpoint
2032    #[test]
2033    fn test_69() {
2034        let params = crate::config::endpoint::Params::builder()
2035            .region("us-east-1".to_string())
2036            .endpoint("https://example.com".to_string())
2037            .use_global_endpoint(true)
2038            .bucket("bucket-name".to_string())
2039            .use_fips(false)
2040            .use_dual_stack(false)
2041            .accelerate(false)
2042            .build()
2043            .expect("invalid params");
2044        let resolver = crate::config::endpoint::DefaultResolver::new();
2045        let endpoint = resolver.resolve_endpoint(&params);
2046        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.example.com");
2047        assert_eq!(
2048            endpoint,
2049            ::aws_smithy_types::endpoint::Endpoint::builder()
2050                .url("https://bucket-name.example.com")
2051                .property(
2052                    "authSchemes",
2053                    vec![{
2054                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2055                        out.insert("name".to_string(), "sigv4".to_string().into());
2056                        out.insert("signingName".to_string(), "s3".to_string().into());
2057                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2058                        out.insert("disableDoubleEncoding".to_string(), true.into());
2059                        out
2060                    }
2061                    .into()]
2062                )
2063                .build()
2064        );
2065    }
2066
2067    /// ForcePathStyle, aws-global region uses the global endpoint
2068    #[test]
2069    fn test_70() {
2070        let params = crate::config::endpoint::Params::builder()
2071            .region("aws-global".to_string())
2072            .bucket("bucket-name".to_string())
2073            .force_path_style(true)
2074            .use_fips(false)
2075            .use_dual_stack(false)
2076            .accelerate(false)
2077            .build()
2078            .expect("invalid params");
2079        let resolver = crate::config::endpoint::DefaultResolver::new();
2080        let endpoint = resolver.resolve_endpoint(&params);
2081        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket-name");
2082        assert_eq!(
2083            endpoint,
2084            ::aws_smithy_types::endpoint::Endpoint::builder()
2085                .url("https://s3.amazonaws.com/bucket-name")
2086                .property(
2087                    "authSchemes",
2088                    vec![{
2089                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2090                        out.insert("name".to_string(), "sigv4".to_string().into());
2091                        out.insert("signingName".to_string(), "s3".to_string().into());
2092                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2093                        out.insert("disableDoubleEncoding".to_string(), true.into());
2094                        out
2095                    }
2096                    .into()]
2097                )
2098                .build()
2099        );
2100    }
2101
2102    /// ForcePathStyle, aws-global region with fips is invalid
2103    #[test]
2104    fn test_71() {
2105        let params = crate::config::endpoint::Params::builder()
2106            .region("aws-global".to_string())
2107            .bucket("bucket-name".to_string())
2108            .force_path_style(true)
2109            .use_fips(true)
2110            .use_dual_stack(false)
2111            .accelerate(false)
2112            .build()
2113            .expect("invalid params");
2114        let resolver = crate::config::endpoint::DefaultResolver::new();
2115        let endpoint = resolver.resolve_endpoint(&params);
2116        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket-name");
2117        assert_eq!(
2118            endpoint,
2119            ::aws_smithy_types::endpoint::Endpoint::builder()
2120                .url("https://s3-fips.us-east-1.amazonaws.com/bucket-name")
2121                .property(
2122                    "authSchemes",
2123                    vec![{
2124                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2125                        out.insert("signingName".to_string(), "s3".to_string().into());
2126                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2127                        out.insert("disableDoubleEncoding".to_string(), true.into());
2128                        out.insert("name".to_string(), "sigv4".to_string().into());
2129                        out
2130                    }
2131                    .into()]
2132                )
2133                .build()
2134        );
2135    }
2136
2137    /// ForcePathStyle, aws-global region with dualstack uses regional dualstack endpoint
2138    #[test]
2139    fn test_72() {
2140        let params = crate::config::endpoint::Params::builder()
2141            .region("aws-global".to_string())
2142            .bucket("bucket-name".to_string())
2143            .force_path_style(true)
2144            .use_fips(false)
2145            .use_dual_stack(true)
2146            .accelerate(false)
2147            .build()
2148            .expect("invalid params");
2149        let resolver = crate::config::endpoint::DefaultResolver::new();
2150        let endpoint = resolver.resolve_endpoint(&params);
2151        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket-name");
2152        assert_eq!(
2153            endpoint,
2154            ::aws_smithy_types::endpoint::Endpoint::builder()
2155                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket-name")
2156                .property(
2157                    "authSchemes",
2158                    vec![{
2159                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2160                        out.insert("name".to_string(), "sigv4".to_string().into());
2161                        out.insert("signingName".to_string(), "s3".to_string().into());
2162                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2163                        out.insert("disableDoubleEncoding".to_string(), true.into());
2164                        out
2165                    }
2166                    .into()]
2167                )
2168                .build()
2169        );
2170    }
2171
2172    /// ForcePathStyle, aws-global region custom endpoint uses the custom endpoint
2173    #[test]
2174    fn test_73() {
2175        let params = crate::config::endpoint::Params::builder()
2176            .region("aws-global".to_string())
2177            .endpoint("https://example.com".to_string())
2178            .bucket("bucket-name".to_string())
2179            .force_path_style(true)
2180            .use_fips(false)
2181            .use_dual_stack(false)
2182            .accelerate(false)
2183            .build()
2184            .expect("invalid params");
2185        let resolver = crate::config::endpoint::DefaultResolver::new();
2186        let endpoint = resolver.resolve_endpoint(&params);
2187        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com/bucket-name");
2188        assert_eq!(
2189            endpoint,
2190            ::aws_smithy_types::endpoint::Endpoint::builder()
2191                .url("https://example.com/bucket-name")
2192                .property(
2193                    "authSchemes",
2194                    vec![{
2195                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2196                        out.insert("name".to_string(), "sigv4".to_string().into());
2197                        out.insert("signingName".to_string(), "s3".to_string().into());
2198                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2199                        out.insert("disableDoubleEncoding".to_string(), true.into());
2200                        out
2201                    }
2202                    .into()]
2203                )
2204                .build()
2205        );
2206    }
2207
2208    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region uses the global endpoint
2209    #[test]
2210    fn test_74() {
2211        let params = crate::config::endpoint::Params::builder()
2212            .region("us-east-1".to_string())
2213            .bucket("bucket-name".to_string())
2214            .use_global_endpoint(true)
2215            .force_path_style(true)
2216            .use_fips(false)
2217            .use_dual_stack(false)
2218            .accelerate(false)
2219            .build()
2220            .expect("invalid params");
2221        let resolver = crate::config::endpoint::DefaultResolver::new();
2222        let endpoint = resolver.resolve_endpoint(&params);
2223        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket-name");
2224        assert_eq!(
2225            endpoint,
2226            ::aws_smithy_types::endpoint::Endpoint::builder()
2227                .url("https://s3.amazonaws.com/bucket-name")
2228                .property(
2229                    "authSchemes",
2230                    vec![{
2231                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2232                        out.insert("name".to_string(), "sigv4".to_string().into());
2233                        out.insert("signingName".to_string(), "s3".to_string().into());
2234                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2235                        out.insert("disableDoubleEncoding".to_string(), true.into());
2236                        out
2237                    }
2238                    .into()]
2239                )
2240                .build()
2241        );
2242    }
2243
2244    /// ForcePathStyle, UseGlobalEndpoint us-west-2 region uses the regional endpoint
2245    #[test]
2246    fn test_75() {
2247        let params = crate::config::endpoint::Params::builder()
2248            .region("us-west-2".to_string())
2249            .bucket("bucket-name".to_string())
2250            .use_global_endpoint(true)
2251            .force_path_style(true)
2252            .use_fips(false)
2253            .use_dual_stack(false)
2254            .accelerate(false)
2255            .build()
2256            .expect("invalid params");
2257        let resolver = crate::config::endpoint::DefaultResolver::new();
2258        let endpoint = resolver.resolve_endpoint(&params);
2259        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket-name");
2260        assert_eq!(
2261            endpoint,
2262            ::aws_smithy_types::endpoint::Endpoint::builder()
2263                .url("https://s3.us-west-2.amazonaws.com/bucket-name")
2264                .property(
2265                    "authSchemes",
2266                    vec![{
2267                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2268                        out.insert("name".to_string(), "sigv4".to_string().into());
2269                        out.insert("signingName".to_string(), "s3".to_string().into());
2270                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2271                        out.insert("disableDoubleEncoding".to_string(), true.into());
2272                        out
2273                    }
2274                    .into()]
2275                )
2276                .build()
2277        );
2278    }
2279
2280    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region, dualstack uses the regional dualstack endpoint
2281    #[test]
2282    fn test_76() {
2283        let params = crate::config::endpoint::Params::builder()
2284            .region("us-east-1".to_string())
2285            .bucket("bucket-name".to_string())
2286            .use_global_endpoint(true)
2287            .force_path_style(true)
2288            .use_fips(false)
2289            .use_dual_stack(true)
2290            .accelerate(false)
2291            .build()
2292            .expect("invalid params");
2293        let resolver = crate::config::endpoint::DefaultResolver::new();
2294        let endpoint = resolver.resolve_endpoint(&params);
2295        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket-name");
2296        assert_eq!(
2297            endpoint,
2298            ::aws_smithy_types::endpoint::Endpoint::builder()
2299                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket-name")
2300                .property(
2301                    "authSchemes",
2302                    vec![{
2303                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2304                        out.insert("name".to_string(), "sigv4".to_string().into());
2305                        out.insert("signingName".to_string(), "s3".to_string().into());
2306                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2307                        out.insert("disableDoubleEncoding".to_string(), true.into());
2308                        out
2309                    }
2310                    .into()]
2311                )
2312                .build()
2313        );
2314    }
2315
2316    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region custom endpoint uses the custom endpoint
2317    #[test]
2318    fn test_77() {
2319        let params = crate::config::endpoint::Params::builder()
2320            .region("us-east-1".to_string())
2321            .bucket("bucket-name".to_string())
2322            .endpoint("https://example.com".to_string())
2323            .use_global_endpoint(true)
2324            .force_path_style(true)
2325            .use_fips(false)
2326            .use_dual_stack(false)
2327            .accelerate(false)
2328            .build()
2329            .expect("invalid params");
2330        let resolver = crate::config::endpoint::DefaultResolver::new();
2331        let endpoint = resolver.resolve_endpoint(&params);
2332        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com/bucket-name");
2333        assert_eq!(
2334            endpoint,
2335            ::aws_smithy_types::endpoint::Endpoint::builder()
2336                .url("https://example.com/bucket-name")
2337                .property(
2338                    "authSchemes",
2339                    vec![{
2340                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2341                        out.insert("name".to_string(), "sigv4".to_string().into());
2342                        out.insert("signingName".to_string(), "s3".to_string().into());
2343                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2344                        out.insert("disableDoubleEncoding".to_string(), true.into());
2345                        out
2346                    }
2347                    .into()]
2348                )
2349                .build()
2350        );
2351    }
2352
2353    /// ARN with aws-global region and  UseArnRegion uses the regional endpoint
2354    #[test]
2355    fn test_78() {
2356        let params = crate::config::endpoint::Params::builder()
2357            .region("aws-global".to_string())
2358            .use_arn_region(true)
2359            .use_fips(false)
2360            .use_dual_stack(false)
2361            .accelerate(false)
2362            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
2363            .build()
2364            .expect("invalid params");
2365        let resolver = crate::config::endpoint::DefaultResolver::new();
2366        let endpoint = resolver.resolve_endpoint(&params);
2367        let endpoint =
2368            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
2369        assert_eq!(
2370            endpoint,
2371            ::aws_smithy_types::endpoint::Endpoint::builder()
2372                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
2373                .property(
2374                    "authSchemes",
2375                    vec![
2376                        {
2377                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2378                            out.insert("name".to_string(), "sigv4a".to_string().into());
2379                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
2380                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
2381                            out.insert("disableDoubleEncoding".to_string(), true.into());
2382                            out
2383                        }
2384                        .into(),
2385                        {
2386                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2387                            out.insert("name".to_string(), "sigv4".to_string().into());
2388                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
2389                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2390                            out.insert("disableDoubleEncoding".to_string(), true.into());
2391                            out
2392                        }
2393                        .into()
2394                    ]
2395                )
2396                .build()
2397        );
2398    }
2399
2400    /// cross partition MRAP ARN is an error
2401    #[test]
2402    fn test_79() {
2403        let params = crate::config::endpoint::Params::builder()
2404            .bucket("arn:aws-cn:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
2405            .region("us-west-1".to_string())
2406            .build()
2407            .expect("invalid params");
2408        let resolver = crate::config::endpoint::DefaultResolver::new();
2409        let endpoint = resolver.resolve_endpoint(&params);
2410        let error = endpoint.expect_err("expected error: Client was configured for partition `aws` but bucket referred to partition `aws-cn` [cross partition MRAP ARN is an error]");
2411        assert_eq!(
2412            format!("{}", error),
2413            "Client was configured for partition `aws` but bucket referred to partition `aws-cn`"
2414        )
2415    }
2416
2417    /// Endpoint override, accesspoint with HTTP, port
2418    #[test]
2419    fn test_80() {
2420        let params = crate::config::endpoint::Params::builder()
2421            .endpoint("http://beta.example.com:1234".to_string())
2422            .region("us-west-2".to_string())
2423            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
2424            .build()
2425            .expect("invalid params");
2426        let resolver = crate::config::endpoint::DefaultResolver::new();
2427        let endpoint = resolver.resolve_endpoint(&params);
2428        let endpoint = endpoint.expect("Expected valid endpoint: http://myendpoint-123456789012.beta.example.com:1234");
2429        assert_eq!(
2430            endpoint,
2431            ::aws_smithy_types::endpoint::Endpoint::builder()
2432                .url("http://myendpoint-123456789012.beta.example.com:1234")
2433                .property(
2434                    "authSchemes",
2435                    vec![{
2436                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2437                        out.insert("name".to_string(), "sigv4".to_string().into());
2438                        out.insert("signingName".to_string(), "s3".to_string().into());
2439                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2440                        out.insert("disableDoubleEncoding".to_string(), true.into());
2441                        out
2442                    }
2443                    .into()]
2444                )
2445                .build()
2446        );
2447    }
2448
2449    /// Endpoint override, accesspoint with http, path, query, and port
2450    #[test]
2451    fn test_81() {
2452        let params = crate::config::endpoint::Params::builder()
2453            .region("us-west-2".to_string())
2454            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
2455            .endpoint("http://beta.example.com:1234/path".to_string())
2456            .use_fips(false)
2457            .use_dual_stack(false)
2458            .accelerate(false)
2459            .build()
2460            .expect("invalid params");
2461        let resolver = crate::config::endpoint::DefaultResolver::new();
2462        let endpoint = resolver.resolve_endpoint(&params);
2463        let endpoint = endpoint.expect("Expected valid endpoint: http://myendpoint-123456789012.beta.example.com:1234/path");
2464        assert_eq!(
2465            endpoint,
2466            ::aws_smithy_types::endpoint::Endpoint::builder()
2467                .url("http://myendpoint-123456789012.beta.example.com:1234/path")
2468                .property(
2469                    "authSchemes",
2470                    vec![{
2471                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2472                        out.insert("name".to_string(), "sigv4".to_string().into());
2473                        out.insert("signingName".to_string(), "s3".to_string().into());
2474                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2475                        out.insert("disableDoubleEncoding".to_string(), true.into());
2476                        out
2477                    }
2478                    .into()]
2479                )
2480                .build()
2481        );
2482    }
2483
2484    /// non-bucket endpoint override with FIPS = error
2485    #[test]
2486    fn test_82() {
2487        let params = crate::config::endpoint::Params::builder()
2488            .region("us-west-2".to_string())
2489            .endpoint("http://beta.example.com:1234/path".to_string())
2490            .use_fips(true)
2491            .use_dual_stack(false)
2492            .build()
2493            .expect("invalid params");
2494        let resolver = crate::config::endpoint::DefaultResolver::new();
2495        let endpoint = resolver.resolve_endpoint(&params);
2496        let error =
2497            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [non-bucket endpoint override with FIPS = error]");
2498        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2499    }
2500
2501    /// FIPS + dualstack + custom endpoint
2502    #[test]
2503    fn test_83() {
2504        let params = crate::config::endpoint::Params::builder()
2505            .region("us-west-2".to_string())
2506            .endpoint("http://beta.example.com:1234/path".to_string())
2507            .use_fips(true)
2508            .use_dual_stack(true)
2509            .build()
2510            .expect("invalid params");
2511        let resolver = crate::config::endpoint::DefaultResolver::new();
2512        let endpoint = resolver.resolve_endpoint(&params);
2513        let error =
2514            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [FIPS + dualstack + custom endpoint]");
2515        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
2516    }
2517
2518    /// dualstack + custom endpoint
2519    #[test]
2520    fn test_84() {
2521        let params = crate::config::endpoint::Params::builder()
2522            .region("us-west-2".to_string())
2523            .endpoint("http://beta.example.com:1234/path".to_string())
2524            .use_fips(false)
2525            .use_dual_stack(true)
2526            .build()
2527            .expect("invalid params");
2528        let resolver = crate::config::endpoint::DefaultResolver::new();
2529        let endpoint = resolver.resolve_endpoint(&params);
2530        let error = endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [dualstack + custom endpoint]");
2531        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
2532    }
2533
2534    /// custom endpoint without FIPS/dualstack
2535    #[test]
2536    fn test_85() {
2537        let params = crate::config::endpoint::Params::builder()
2538            .region("us-west-2".to_string())
2539            .endpoint("http://beta.example.com:1234/path".to_string())
2540            .use_fips(false)
2541            .use_dual_stack(false)
2542            .build()
2543            .expect("invalid params");
2544        let resolver = crate::config::endpoint::DefaultResolver::new();
2545        let endpoint = resolver.resolve_endpoint(&params);
2546        let endpoint = endpoint.expect("Expected valid endpoint: http://beta.example.com:1234/path");
2547        assert_eq!(
2548            endpoint,
2549            ::aws_smithy_types::endpoint::Endpoint::builder()
2550                .url("http://beta.example.com:1234/path")
2551                .property(
2552                    "authSchemes",
2553                    vec![{
2554                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2555                        out.insert("name".to_string(), "sigv4".to_string().into());
2556                        out.insert("signingName".to_string(), "s3".to_string().into());
2557                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2558                        out.insert("disableDoubleEncoding".to_string(), true.into());
2559                        out
2560                    }
2561                    .into()]
2562                )
2563                .build()
2564        );
2565    }
2566
2567    /// s3 object lambda with access points disabled
2568    #[test]
2569    fn test_86() {
2570        let params = crate::config::endpoint::Params::builder()
2571            .region("us-west-2".to_string())
2572            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:myendpoint".to_string())
2573            .disable_access_points(true)
2574            .build()
2575            .expect("invalid params");
2576        let resolver = crate::config::endpoint::DefaultResolver::new();
2577        let endpoint = resolver.resolve_endpoint(&params);
2578        let error =
2579            endpoint.expect_err("expected error: Access points are not supported for this operation [s3 object lambda with access points disabled]");
2580        assert_eq!(format!("{}", error), "Access points are not supported for this operation")
2581    }
2582
2583    /// non bucket + FIPS
2584    #[test]
2585    fn test_87() {
2586        let params = crate::config::endpoint::Params::builder()
2587            .region("us-west-2".to_string())
2588            .use_fips(true)
2589            .use_dual_stack(false)
2590            .build()
2591            .expect("invalid params");
2592        let resolver = crate::config::endpoint::DefaultResolver::new();
2593        let endpoint = resolver.resolve_endpoint(&params);
2594        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-west-2.amazonaws.com");
2595        assert_eq!(
2596            endpoint,
2597            ::aws_smithy_types::endpoint::Endpoint::builder()
2598                .url("https://s3-fips.us-west-2.amazonaws.com")
2599                .property(
2600                    "authSchemes",
2601                    vec![{
2602                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2603                        out.insert("name".to_string(), "sigv4".to_string().into());
2604                        out.insert("signingName".to_string(), "s3".to_string().into());
2605                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2606                        out.insert("disableDoubleEncoding".to_string(), true.into());
2607                        out
2608                    }
2609                    .into()]
2610                )
2611                .build()
2612        );
2613    }
2614
2615    /// standard non bucket endpoint
2616    #[test]
2617    fn test_88() {
2618        let params = crate::config::endpoint::Params::builder()
2619            .region("us-west-2".to_string())
2620            .use_fips(false)
2621            .use_dual_stack(false)
2622            .build()
2623            .expect("invalid params");
2624        let resolver = crate::config::endpoint::DefaultResolver::new();
2625        let endpoint = resolver.resolve_endpoint(&params);
2626        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com");
2627        assert_eq!(
2628            endpoint,
2629            ::aws_smithy_types::endpoint::Endpoint::builder()
2630                .url("https://s3.us-west-2.amazonaws.com")
2631                .property(
2632                    "authSchemes",
2633                    vec![{
2634                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2635                        out.insert("name".to_string(), "sigv4".to_string().into());
2636                        out.insert("signingName".to_string(), "s3".to_string().into());
2637                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2638                        out.insert("disableDoubleEncoding".to_string(), true.into());
2639                        out
2640                    }
2641                    .into()]
2642                )
2643                .build()
2644        );
2645    }
2646
2647    /// non bucket endpoint with FIPS + Dualstack
2648    #[test]
2649    fn test_89() {
2650        let params = crate::config::endpoint::Params::builder()
2651            .region("us-west-2".to_string())
2652            .use_fips(true)
2653            .use_dual_stack(true)
2654            .build()
2655            .expect("invalid params");
2656        let resolver = crate::config::endpoint::DefaultResolver::new();
2657        let endpoint = resolver.resolve_endpoint(&params);
2658        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-west-2.amazonaws.com");
2659        assert_eq!(
2660            endpoint,
2661            ::aws_smithy_types::endpoint::Endpoint::builder()
2662                .url("https://s3-fips.dualstack.us-west-2.amazonaws.com")
2663                .property(
2664                    "authSchemes",
2665                    vec![{
2666                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2667                        out.insert("name".to_string(), "sigv4".to_string().into());
2668                        out.insert("signingName".to_string(), "s3".to_string().into());
2669                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2670                        out.insert("disableDoubleEncoding".to_string(), true.into());
2671                        out
2672                    }
2673                    .into()]
2674                )
2675                .build()
2676        );
2677    }
2678
2679    /// non bucket endpoint with dualstack
2680    #[test]
2681    fn test_90() {
2682        let params = crate::config::endpoint::Params::builder()
2683            .region("us-west-2".to_string())
2684            .use_fips(false)
2685            .use_dual_stack(true)
2686            .build()
2687            .expect("invalid params");
2688        let resolver = crate::config::endpoint::DefaultResolver::new();
2689        let endpoint = resolver.resolve_endpoint(&params);
2690        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com");
2691        assert_eq!(
2692            endpoint,
2693            ::aws_smithy_types::endpoint::Endpoint::builder()
2694                .url("https://s3.dualstack.us-west-2.amazonaws.com")
2695                .property(
2696                    "authSchemes",
2697                    vec![{
2698                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2699                        out.insert("name".to_string(), "sigv4".to_string().into());
2700                        out.insert("signingName".to_string(), "s3".to_string().into());
2701                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2702                        out.insert("disableDoubleEncoding".to_string(), true.into());
2703                        out
2704                    }
2705                    .into()]
2706                )
2707                .build()
2708        );
2709    }
2710
2711    /// use global endpoint + IP address endpoint override
2712    #[test]
2713    fn test_91() {
2714        let params = crate::config::endpoint::Params::builder()
2715            .region("us-east-1".to_string())
2716            .bucket("bucket".to_string())
2717            .use_fips(false)
2718            .use_dual_stack(false)
2719            .endpoint("http://127.0.0.1".to_string())
2720            .use_global_endpoint(true)
2721            .build()
2722            .expect("invalid params");
2723        let resolver = crate::config::endpoint::DefaultResolver::new();
2724        let endpoint = resolver.resolve_endpoint(&params);
2725        let endpoint = endpoint.expect("Expected valid endpoint: http://127.0.0.1/bucket");
2726        assert_eq!(
2727            endpoint,
2728            ::aws_smithy_types::endpoint::Endpoint::builder()
2729                .url("http://127.0.0.1/bucket")
2730                .property(
2731                    "authSchemes",
2732                    vec![{
2733                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2734                        out.insert("name".to_string(), "sigv4".to_string().into());
2735                        out.insert("signingName".to_string(), "s3".to_string().into());
2736                        out.insert("disableDoubleEncoding".to_string(), true.into());
2737                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2738                        out
2739                    }
2740                    .into()]
2741                )
2742                .build()
2743        );
2744    }
2745
2746    /// non-dns endpoint + global endpoint
2747    #[test]
2748    fn test_92() {
2749        let params = crate::config::endpoint::Params::builder()
2750            .region("us-east-1".to_string())
2751            .bucket("bucket!".to_string())
2752            .use_fips(false)
2753            .use_dual_stack(false)
2754            .use_global_endpoint(true)
2755            .build()
2756            .expect("invalid params");
2757        let resolver = crate::config::endpoint::DefaultResolver::new();
2758        let endpoint = resolver.resolve_endpoint(&params);
2759        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket%21");
2760        assert_eq!(
2761            endpoint,
2762            ::aws_smithy_types::endpoint::Endpoint::builder()
2763                .url("https://s3.amazonaws.com/bucket%21")
2764                .property(
2765                    "authSchemes",
2766                    vec![{
2767                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2768                        out.insert("name".to_string(), "sigv4".to_string().into());
2769                        out.insert("signingName".to_string(), "s3".to_string().into());
2770                        out.insert("disableDoubleEncoding".to_string(), true.into());
2771                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2772                        out
2773                    }
2774                    .into()]
2775                )
2776                .build()
2777        );
2778    }
2779
2780    /// endpoint override + use global endpoint
2781    #[test]
2782    fn test_93() {
2783        let params = crate::config::endpoint::Params::builder()
2784            .region("us-east-1".to_string())
2785            .bucket("bucket!".to_string())
2786            .use_fips(false)
2787            .use_dual_stack(false)
2788            .use_global_endpoint(true)
2789            .endpoint("http://foo.com".to_string())
2790            .build()
2791            .expect("invalid params");
2792        let resolver = crate::config::endpoint::DefaultResolver::new();
2793        let endpoint = resolver.resolve_endpoint(&params);
2794        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
2795        assert_eq!(
2796            endpoint,
2797            ::aws_smithy_types::endpoint::Endpoint::builder()
2798                .url("http://foo.com/bucket%21")
2799                .property(
2800                    "authSchemes",
2801                    vec![{
2802                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2803                        out.insert("name".to_string(), "sigv4".to_string().into());
2804                        out.insert("signingName".to_string(), "s3".to_string().into());
2805                        out.insert("disableDoubleEncoding".to_string(), true.into());
2806                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2807                        out
2808                    }
2809                    .into()]
2810                )
2811                .build()
2812        );
2813    }
2814
2815    /// FIPS + dualstack + non-bucket endpoint
2816    #[test]
2817    fn test_94() {
2818        let params = crate::config::endpoint::Params::builder()
2819            .region("us-east-1".to_string())
2820            .bucket("bucket!".to_string())
2821            .use_fips(true)
2822            .use_dual_stack(true)
2823            .build()
2824            .expect("invalid params");
2825        let resolver = crate::config::endpoint::DefaultResolver::new();
2826        let endpoint = resolver.resolve_endpoint(&params);
2827        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
2828        assert_eq!(
2829            endpoint,
2830            ::aws_smithy_types::endpoint::Endpoint::builder()
2831                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
2832                .property(
2833                    "authSchemes",
2834                    vec![{
2835                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2836                        out.insert("name".to_string(), "sigv4".to_string().into());
2837                        out.insert("signingName".to_string(), "s3".to_string().into());
2838                        out.insert("disableDoubleEncoding".to_string(), true.into());
2839                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2840                        out
2841                    }
2842                    .into()]
2843                )
2844                .build()
2845        );
2846    }
2847
2848    /// FIPS + dualstack + non-DNS endpoint
2849    #[test]
2850    fn test_95() {
2851        let params = crate::config::endpoint::Params::builder()
2852            .region("us-east-1".to_string())
2853            .bucket("bucket!".to_string())
2854            .force_path_style(true)
2855            .use_fips(true)
2856            .use_dual_stack(true)
2857            .build()
2858            .expect("invalid params");
2859        let resolver = crate::config::endpoint::DefaultResolver::new();
2860        let endpoint = resolver.resolve_endpoint(&params);
2861        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
2862        assert_eq!(
2863            endpoint,
2864            ::aws_smithy_types::endpoint::Endpoint::builder()
2865                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
2866                .property(
2867                    "authSchemes",
2868                    vec![{
2869                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2870                        out.insert("name".to_string(), "sigv4".to_string().into());
2871                        out.insert("signingName".to_string(), "s3".to_string().into());
2872                        out.insert("disableDoubleEncoding".to_string(), true.into());
2873                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2874                        out
2875                    }
2876                    .into()]
2877                )
2878                .build()
2879        );
2880    }
2881
2882    /// endpoint override + FIPS + dualstack (BUG)
2883    #[test]
2884    fn test_96() {
2885        let params = crate::config::endpoint::Params::builder()
2886            .region("us-east-1".to_string())
2887            .bucket("bucket!".to_string())
2888            .force_path_style(true)
2889            .use_fips(true)
2890            .use_dual_stack(false)
2891            .endpoint("http://foo.com".to_string())
2892            .build()
2893            .expect("invalid params");
2894        let resolver = crate::config::endpoint::DefaultResolver::new();
2895        let endpoint = resolver.resolve_endpoint(&params);
2896        let error =
2897            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [endpoint override + FIPS + dualstack (BUG)]");
2898        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2899    }
2900
2901    /// endpoint override + non-dns bucket + FIPS (BUG)
2902    #[test]
2903    fn test_97() {
2904        let params = crate::config::endpoint::Params::builder()
2905            .region("us-east-1".to_string())
2906            .bucket("bucket!".to_string())
2907            .use_fips(true)
2908            .use_dual_stack(false)
2909            .endpoint("http://foo.com".to_string())
2910            .build()
2911            .expect("invalid params");
2912        let resolver = crate::config::endpoint::DefaultResolver::new();
2913        let endpoint = resolver.resolve_endpoint(&params);
2914        let error =
2915            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [endpoint override + non-dns bucket + FIPS (BUG)]");
2916        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2917    }
2918
2919    /// FIPS + bucket endpoint + force path style
2920    #[test]
2921    fn test_98() {
2922        let params = crate::config::endpoint::Params::builder()
2923            .region("us-east-1".to_string())
2924            .bucket("bucket!".to_string())
2925            .force_path_style(true)
2926            .use_fips(true)
2927            .use_dual_stack(false)
2928            .use_global_endpoint(true)
2929            .build()
2930            .expect("invalid params");
2931        let resolver = crate::config::endpoint::DefaultResolver::new();
2932        let endpoint = resolver.resolve_endpoint(&params);
2933        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
2934        assert_eq!(
2935            endpoint,
2936            ::aws_smithy_types::endpoint::Endpoint::builder()
2937                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
2938                .property(
2939                    "authSchemes",
2940                    vec![{
2941                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2942                        out.insert("name".to_string(), "sigv4".to_string().into());
2943                        out.insert("signingName".to_string(), "s3".to_string().into());
2944                        out.insert("disableDoubleEncoding".to_string(), true.into());
2945                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2946                        out
2947                    }
2948                    .into()]
2949                )
2950                .build()
2951        );
2952    }
2953
2954    /// bucket + FIPS + force path style
2955    #[test]
2956    fn test_99() {
2957        let params = crate::config::endpoint::Params::builder()
2958            .region("us-east-1".to_string())
2959            .bucket("bucket".to_string())
2960            .force_path_style(true)
2961            .use_fips(true)
2962            .use_dual_stack(true)
2963            .use_global_endpoint(true)
2964            .build()
2965            .expect("invalid params");
2966        let resolver = crate::config::endpoint::DefaultResolver::new();
2967        let endpoint = resolver.resolve_endpoint(&params);
2968        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket");
2969        assert_eq!(
2970            endpoint,
2971            ::aws_smithy_types::endpoint::Endpoint::builder()
2972                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket")
2973                .property(
2974                    "authSchemes",
2975                    vec![{
2976                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2977                        out.insert("name".to_string(), "sigv4".to_string().into());
2978                        out.insert("signingName".to_string(), "s3".to_string().into());
2979                        out.insert("disableDoubleEncoding".to_string(), true.into());
2980                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2981                        out
2982                    }
2983                    .into()]
2984                )
2985                .build()
2986        );
2987    }
2988
2989    /// FIPS + dualstack + use global endpoint
2990    #[test]
2991    fn test_100() {
2992        let params = crate::config::endpoint::Params::builder()
2993            .region("us-east-1".to_string())
2994            .bucket("bucket".to_string())
2995            .use_fips(true)
2996            .use_dual_stack(true)
2997            .use_global_endpoint(true)
2998            .build()
2999            .expect("invalid params");
3000        let resolver = crate::config::endpoint::DefaultResolver::new();
3001        let endpoint = resolver.resolve_endpoint(&params);
3002        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-fips.dualstack.us-east-1.amazonaws.com");
3003        assert_eq!(
3004            endpoint,
3005            ::aws_smithy_types::endpoint::Endpoint::builder()
3006                .url("https://bucket.s3-fips.dualstack.us-east-1.amazonaws.com")
3007                .property(
3008                    "authSchemes",
3009                    vec![{
3010                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3011                        out.insert("name".to_string(), "sigv4".to_string().into());
3012                        out.insert("signingName".to_string(), "s3".to_string().into());
3013                        out.insert("disableDoubleEncoding".to_string(), true.into());
3014                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3015                        out
3016                    }
3017                    .into()]
3018                )
3019                .build()
3020        );
3021    }
3022
3023    /// URI encoded bucket + use global endpoint
3024    #[test]
3025    fn test_101() {
3026        let params = crate::config::endpoint::Params::builder()
3027            .region("us-east-1".to_string())
3028            .bucket("bucket!".to_string())
3029            .use_fips(true)
3030            .use_dual_stack(false)
3031            .use_global_endpoint(true)
3032            .endpoint("https://foo.com".to_string())
3033            .build()
3034            .expect("invalid params");
3035        let resolver = crate::config::endpoint::DefaultResolver::new();
3036        let endpoint = resolver.resolve_endpoint(&params);
3037        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [URI encoded bucket + use global endpoint]");
3038        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3039    }
3040
3041    /// FIPS + path based endpoint
3042    #[test]
3043    fn test_102() {
3044        let params = crate::config::endpoint::Params::builder()
3045            .region("us-east-1".to_string())
3046            .bucket("bucket!".to_string())
3047            .use_fips(true)
3048            .use_dual_stack(false)
3049            .accelerate(false)
3050            .use_global_endpoint(true)
3051            .build()
3052            .expect("invalid params");
3053        let resolver = crate::config::endpoint::DefaultResolver::new();
3054        let endpoint = resolver.resolve_endpoint(&params);
3055        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
3056        assert_eq!(
3057            endpoint,
3058            ::aws_smithy_types::endpoint::Endpoint::builder()
3059                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
3060                .property(
3061                    "authSchemes",
3062                    vec![{
3063                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3064                        out.insert("name".to_string(), "sigv4".to_string().into());
3065                        out.insert("signingName".to_string(), "s3".to_string().into());
3066                        out.insert("disableDoubleEncoding".to_string(), true.into());
3067                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3068                        out
3069                    }
3070                    .into()]
3071                )
3072                .build()
3073        );
3074    }
3075
3076    /// accelerate + dualstack + global endpoint
3077    #[test]
3078    fn test_103() {
3079        let params = crate::config::endpoint::Params::builder()
3080            .region("us-east-1".to_string())
3081            .bucket("bucket".to_string())
3082            .use_fips(false)
3083            .use_dual_stack(true)
3084            .accelerate(true)
3085            .use_global_endpoint(true)
3086            .build()
3087            .expect("invalid params");
3088        let resolver = crate::config::endpoint::DefaultResolver::new();
3089        let endpoint = resolver.resolve_endpoint(&params);
3090        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.dualstack.amazonaws.com");
3091        assert_eq!(
3092            endpoint,
3093            ::aws_smithy_types::endpoint::Endpoint::builder()
3094                .url("https://bucket.s3-accelerate.dualstack.amazonaws.com")
3095                .property(
3096                    "authSchemes",
3097                    vec![{
3098                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3099                        out.insert("name".to_string(), "sigv4".to_string().into());
3100                        out.insert("signingName".to_string(), "s3".to_string().into());
3101                        out.insert("disableDoubleEncoding".to_string(), true.into());
3102                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3103                        out
3104                    }
3105                    .into()]
3106                )
3107                .build()
3108        );
3109    }
3110
3111    /// dualstack + global endpoint + non URI safe bucket
3112    #[test]
3113    fn test_104() {
3114        let params = crate::config::endpoint::Params::builder()
3115            .region("us-east-1".to_string())
3116            .bucket("bucket!".to_string())
3117            .accelerate(false)
3118            .use_dual_stack(true)
3119            .use_fips(false)
3120            .use_global_endpoint(true)
3121            .build()
3122            .expect("invalid params");
3123        let resolver = crate::config::endpoint::DefaultResolver::new();
3124        let endpoint = resolver.resolve_endpoint(&params);
3125        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket%21");
3126        assert_eq!(
3127            endpoint,
3128            ::aws_smithy_types::endpoint::Endpoint::builder()
3129                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket%21")
3130                .property(
3131                    "authSchemes",
3132                    vec![{
3133                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3134                        out.insert("name".to_string(), "sigv4".to_string().into());
3135                        out.insert("signingName".to_string(), "s3".to_string().into());
3136                        out.insert("disableDoubleEncoding".to_string(), true.into());
3137                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3138                        out
3139                    }
3140                    .into()]
3141                )
3142                .build()
3143        );
3144    }
3145
3146    /// FIPS + uri encoded bucket
3147    #[test]
3148    fn test_105() {
3149        let params = crate::config::endpoint::Params::builder()
3150            .region("us-east-1".to_string())
3151            .bucket("bucket!".to_string())
3152            .force_path_style(true)
3153            .accelerate(false)
3154            .use_dual_stack(false)
3155            .use_fips(true)
3156            .use_global_endpoint(true)
3157            .build()
3158            .expect("invalid params");
3159        let resolver = crate::config::endpoint::DefaultResolver::new();
3160        let endpoint = resolver.resolve_endpoint(&params);
3161        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
3162        assert_eq!(
3163            endpoint,
3164            ::aws_smithy_types::endpoint::Endpoint::builder()
3165                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
3166                .property(
3167                    "authSchemes",
3168                    vec![{
3169                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3170                        out.insert("name".to_string(), "sigv4".to_string().into());
3171                        out.insert("signingName".to_string(), "s3".to_string().into());
3172                        out.insert("disableDoubleEncoding".to_string(), true.into());
3173                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3174                        out
3175                    }
3176                    .into()]
3177                )
3178                .build()
3179        );
3180    }
3181
3182    /// endpoint override + non-uri safe endpoint + force path style
3183    #[test]
3184    fn test_106() {
3185        let params = crate::config::endpoint::Params::builder()
3186            .region("us-east-1".to_string())
3187            .bucket("bucket!".to_string())
3188            .force_path_style(true)
3189            .accelerate(false)
3190            .use_dual_stack(false)
3191            .use_fips(true)
3192            .endpoint("http://foo.com".to_string())
3193            .use_global_endpoint(true)
3194            .build()
3195            .expect("invalid params");
3196        let resolver = crate::config::endpoint::DefaultResolver::new();
3197        let endpoint = resolver.resolve_endpoint(&params);
3198        let error = endpoint.expect_err(
3199            "expected error: A custom endpoint cannot be combined with FIPS [endpoint override + non-uri safe endpoint + force path style]",
3200        );
3201        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3202    }
3203
3204    /// FIPS + Dualstack + global endpoint + non-dns bucket
3205    #[test]
3206    fn test_107() {
3207        let params = crate::config::endpoint::Params::builder()
3208            .region("us-east-1".to_string())
3209            .bucket("bucket!".to_string())
3210            .accelerate(false)
3211            .use_dual_stack(true)
3212            .use_fips(true)
3213            .use_global_endpoint(true)
3214            .build()
3215            .expect("invalid params");
3216        let resolver = crate::config::endpoint::DefaultResolver::new();
3217        let endpoint = resolver.resolve_endpoint(&params);
3218        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
3219        assert_eq!(
3220            endpoint,
3221            ::aws_smithy_types::endpoint::Endpoint::builder()
3222                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
3223                .property(
3224                    "authSchemes",
3225                    vec![{
3226                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3227                        out.insert("name".to_string(), "sigv4".to_string().into());
3228                        out.insert("signingName".to_string(), "s3".to_string().into());
3229                        out.insert("disableDoubleEncoding".to_string(), true.into());
3230                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3231                        out
3232                    }
3233                    .into()]
3234                )
3235                .build()
3236        );
3237    }
3238
3239    /// endpoint override + FIPS + dualstack
3240    #[test]
3241    fn test_108() {
3242        let params = crate::config::endpoint::Params::builder()
3243            .region("us-east-1".to_string())
3244            .use_dual_stack(true)
3245            .use_fips(true)
3246            .use_global_endpoint(true)
3247            .endpoint("http://foo.com".to_string())
3248            .build()
3249            .expect("invalid params");
3250        let resolver = crate::config::endpoint::DefaultResolver::new();
3251        let endpoint = resolver.resolve_endpoint(&params);
3252        let error = endpoint
3253            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [endpoint override + FIPS + dualstack]");
3254        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3255    }
3256
3257    /// non-bucket endpoint override + dualstack + global endpoint
3258    #[test]
3259    fn test_109() {
3260        let params = crate::config::endpoint::Params::builder()
3261            .region("us-east-1".to_string())
3262            .use_fips(false)
3263            .use_dual_stack(true)
3264            .use_global_endpoint(true)
3265            .endpoint("http://foo.com".to_string())
3266            .build()
3267            .expect("invalid params");
3268        let resolver = crate::config::endpoint::DefaultResolver::new();
3269        let endpoint = resolver.resolve_endpoint(&params);
3270        let error = endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [non-bucket endpoint override + dualstack + global endpoint]");
3271        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3272    }
3273
3274    /// Endpoint override + UseGlobalEndpoint + us-east-1
3275    #[test]
3276    fn test_110() {
3277        let params = crate::config::endpoint::Params::builder()
3278            .region("us-east-1".to_string())
3279            .use_fips(true)
3280            .use_dual_stack(false)
3281            .use_global_endpoint(true)
3282            .endpoint("http://foo.com".to_string())
3283            .build()
3284            .expect("invalid params");
3285        let resolver = crate::config::endpoint::DefaultResolver::new();
3286        let endpoint = resolver.resolve_endpoint(&params);
3287        let error =
3288            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [Endpoint override + UseGlobalEndpoint + us-east-1]");
3289        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3290    }
3291
3292    /// non-FIPS partition with FIPS set + custom endpoint
3293    #[test]
3294    fn test_111() {
3295        let params = crate::config::endpoint::Params::builder()
3296            .region("cn-north-1".to_string())
3297            .use_fips(true)
3298            .use_dual_stack(false)
3299            .use_global_endpoint(true)
3300            .build()
3301            .expect("invalid params");
3302        let resolver = crate::config::endpoint::DefaultResolver::new();
3303        let endpoint = resolver.resolve_endpoint(&params);
3304        let error = endpoint.expect_err("expected error: Partition does not support FIPS [non-FIPS partition with FIPS set + custom endpoint]");
3305        assert_eq!(format!("{}", error), "Partition does not support FIPS")
3306    }
3307
3308    /// aws-global signs as us-east-1
3309    #[test]
3310    fn test_112() {
3311        let params = crate::config::endpoint::Params::builder()
3312            .region("aws-global".to_string())
3313            .bucket("bucket!".to_string())
3314            .use_fips(true)
3315            .accelerate(false)
3316            .use_dual_stack(true)
3317            .build()
3318            .expect("invalid params");
3319        let resolver = crate::config::endpoint::DefaultResolver::new();
3320        let endpoint = resolver.resolve_endpoint(&params);
3321        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
3322        assert_eq!(
3323            endpoint,
3324            ::aws_smithy_types::endpoint::Endpoint::builder()
3325                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
3326                .property(
3327                    "authSchemes",
3328                    vec![{
3329                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3330                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3331                        out.insert("name".to_string(), "sigv4".to_string().into());
3332                        out.insert("signingName".to_string(), "s3".to_string().into());
3333                        out.insert("disableDoubleEncoding".to_string(), true.into());
3334                        out
3335                    }
3336                    .into()]
3337                )
3338                .build()
3339        );
3340    }
3341
3342    /// aws-global signs as us-east-1
3343    #[test]
3344    fn test_113() {
3345        let params = crate::config::endpoint::Params::builder()
3346            .region("aws-global".to_string())
3347            .bucket("bucket".to_string())
3348            .use_dual_stack(false)
3349            .use_fips(false)
3350            .accelerate(false)
3351            .endpoint("https://foo.com".to_string())
3352            .build()
3353            .expect("invalid params");
3354        let resolver = crate::config::endpoint::DefaultResolver::new();
3355        let endpoint = resolver.resolve_endpoint(&params);
3356        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.foo.com");
3357        assert_eq!(
3358            endpoint,
3359            ::aws_smithy_types::endpoint::Endpoint::builder()
3360                .url("https://bucket.foo.com")
3361                .property(
3362                    "authSchemes",
3363                    vec![{
3364                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3365                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3366                        out.insert("name".to_string(), "sigv4".to_string().into());
3367                        out.insert("signingName".to_string(), "s3".to_string().into());
3368                        out.insert("disableDoubleEncoding".to_string(), true.into());
3369                        out
3370                    }
3371                    .into()]
3372                )
3373                .build()
3374        );
3375    }
3376
3377    /// aws-global + dualstack + path-only bucket
3378    #[test]
3379    fn test_114() {
3380        let params = crate::config::endpoint::Params::builder()
3381            .region("aws-global".to_string())
3382            .bucket("bucket!".to_string())
3383            .use_dual_stack(true)
3384            .use_fips(false)
3385            .accelerate(false)
3386            .build()
3387            .expect("invalid params");
3388        let resolver = crate::config::endpoint::DefaultResolver::new();
3389        let endpoint = resolver.resolve_endpoint(&params);
3390        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket%21");
3391        assert_eq!(
3392            endpoint,
3393            ::aws_smithy_types::endpoint::Endpoint::builder()
3394                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket%21")
3395                .property(
3396                    "authSchemes",
3397                    vec![{
3398                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3399                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3400                        out.insert("name".to_string(), "sigv4".to_string().into());
3401                        out.insert("signingName".to_string(), "s3".to_string().into());
3402                        out.insert("disableDoubleEncoding".to_string(), true.into());
3403                        out
3404                    }
3405                    .into()]
3406                )
3407                .build()
3408        );
3409    }
3410
3411    /// aws-global + path-only bucket
3412    #[test]
3413    fn test_115() {
3414        let params = crate::config::endpoint::Params::builder()
3415            .region("aws-global".to_string())
3416            .bucket("bucket!".to_string())
3417            .build()
3418            .expect("invalid params");
3419        let resolver = crate::config::endpoint::DefaultResolver::new();
3420        let endpoint = resolver.resolve_endpoint(&params);
3421        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket%21");
3422        assert_eq!(
3423            endpoint,
3424            ::aws_smithy_types::endpoint::Endpoint::builder()
3425                .url("https://s3.amazonaws.com/bucket%21")
3426                .property(
3427                    "authSchemes",
3428                    vec![{
3429                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3430                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3431                        out.insert("name".to_string(), "sigv4".to_string().into());
3432                        out.insert("signingName".to_string(), "s3".to_string().into());
3433                        out.insert("disableDoubleEncoding".to_string(), true.into());
3434                        out
3435                    }
3436                    .into()]
3437                )
3438                .build()
3439        );
3440    }
3441
3442    /// aws-global + fips + custom endpoint
3443    #[test]
3444    fn test_116() {
3445        let params = crate::config::endpoint::Params::builder()
3446            .region("aws-global".to_string())
3447            .bucket("bucket!".to_string())
3448            .use_dual_stack(false)
3449            .use_fips(true)
3450            .accelerate(false)
3451            .endpoint("http://foo.com".to_string())
3452            .build()
3453            .expect("invalid params");
3454        let resolver = crate::config::endpoint::DefaultResolver::new();
3455        let endpoint = resolver.resolve_endpoint(&params);
3456        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [aws-global + fips + custom endpoint]");
3457        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3458    }
3459
3460    /// aws-global, endpoint override & path only-bucket
3461    #[test]
3462    fn test_117() {
3463        let params = crate::config::endpoint::Params::builder()
3464            .region("aws-global".to_string())
3465            .bucket("bucket!".to_string())
3466            .use_dual_stack(false)
3467            .use_fips(false)
3468            .accelerate(false)
3469            .endpoint("http://foo.com".to_string())
3470            .build()
3471            .expect("invalid params");
3472        let resolver = crate::config::endpoint::DefaultResolver::new();
3473        let endpoint = resolver.resolve_endpoint(&params);
3474        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
3475        assert_eq!(
3476            endpoint,
3477            ::aws_smithy_types::endpoint::Endpoint::builder()
3478                .url("http://foo.com/bucket%21")
3479                .property(
3480                    "authSchemes",
3481                    vec![{
3482                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3483                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3484                        out.insert("name".to_string(), "sigv4".to_string().into());
3485                        out.insert("signingName".to_string(), "s3".to_string().into());
3486                        out.insert("disableDoubleEncoding".to_string(), true.into());
3487                        out
3488                    }
3489                    .into()]
3490                )
3491                .build()
3492        );
3493    }
3494
3495    /// aws-global + dualstack + custom endpoint
3496    #[test]
3497    fn test_118() {
3498        let params = crate::config::endpoint::Params::builder()
3499            .region("aws-global".to_string())
3500            .use_dual_stack(true)
3501            .use_fips(false)
3502            .accelerate(false)
3503            .endpoint("http://foo.com".to_string())
3504            .build()
3505            .expect("invalid params");
3506        let resolver = crate::config::endpoint::DefaultResolver::new();
3507        let endpoint = resolver.resolve_endpoint(&params);
3508        let error = endpoint
3509            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [aws-global + dualstack + custom endpoint]");
3510        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3511    }
3512
3513    /// accelerate, dualstack + aws-global
3514    #[test]
3515    fn test_119() {
3516        let params = crate::config::endpoint::Params::builder()
3517            .region("aws-global".to_string())
3518            .bucket("bucket".to_string())
3519            .use_dual_stack(true)
3520            .use_fips(false)
3521            .accelerate(true)
3522            .build()
3523            .expect("invalid params");
3524        let resolver = crate::config::endpoint::DefaultResolver::new();
3525        let endpoint = resolver.resolve_endpoint(&params);
3526        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.dualstack.us-east-1.amazonaws.com");
3527        assert_eq!(
3528            endpoint,
3529            ::aws_smithy_types::endpoint::Endpoint::builder()
3530                .url("https://bucket.s3-accelerate.dualstack.us-east-1.amazonaws.com")
3531                .property(
3532                    "authSchemes",
3533                    vec![{
3534                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3535                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3536                        out.insert("name".to_string(), "sigv4".to_string().into());
3537                        out.insert("signingName".to_string(), "s3".to_string().into());
3538                        out.insert("disableDoubleEncoding".to_string(), true.into());
3539                        out
3540                    }
3541                    .into()]
3542                )
3543                .build()
3544        );
3545    }
3546
3547    /// FIPS + aws-global + path only bucket. This is not supported by S3 but we allow garbage in garbage out
3548    #[test]
3549    fn test_120() {
3550        let params = crate::config::endpoint::Params::builder()
3551            .region("aws-global".to_string())
3552            .bucket("bucket!".to_string())
3553            .force_path_style(true)
3554            .use_dual_stack(true)
3555            .use_fips(true)
3556            .accelerate(false)
3557            .build()
3558            .expect("invalid params");
3559        let resolver = crate::config::endpoint::DefaultResolver::new();
3560        let endpoint = resolver.resolve_endpoint(&params);
3561        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
3562        assert_eq!(
3563            endpoint,
3564            ::aws_smithy_types::endpoint::Endpoint::builder()
3565                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
3566                .property(
3567                    "authSchemes",
3568                    vec![{
3569                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3570                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3571                        out.insert("name".to_string(), "sigv4".to_string().into());
3572                        out.insert("signingName".to_string(), "s3".to_string().into());
3573                        out.insert("disableDoubleEncoding".to_string(), true.into());
3574                        out
3575                    }
3576                    .into()]
3577                )
3578                .build()
3579        );
3580    }
3581
3582    /// aws-global + FIPS + endpoint override.
3583    #[test]
3584    fn test_121() {
3585        let params = crate::config::endpoint::Params::builder()
3586            .region("aws-global".to_string())
3587            .use_fips(true)
3588            .endpoint("http://foo.com".to_string())
3589            .build()
3590            .expect("invalid params");
3591        let resolver = crate::config::endpoint::DefaultResolver::new();
3592        let endpoint = resolver.resolve_endpoint(&params);
3593        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [aws-global + FIPS + endpoint override.]");
3594        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3595    }
3596
3597    /// force path style, FIPS, aws-global & endpoint override
3598    #[test]
3599    fn test_122() {
3600        let params = crate::config::endpoint::Params::builder()
3601            .region("aws-global".to_string())
3602            .bucket("bucket!".to_string())
3603            .force_path_style(true)
3604            .use_fips(true)
3605            .endpoint("http://foo.com".to_string())
3606            .build()
3607            .expect("invalid params");
3608        let resolver = crate::config::endpoint::DefaultResolver::new();
3609        let endpoint = resolver.resolve_endpoint(&params);
3610        let error = endpoint
3611            .expect_err("expected error: A custom endpoint cannot be combined with FIPS [force path style, FIPS, aws-global & endpoint override]");
3612        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3613    }
3614
3615    /// ip address causes path style to be forced
3616    #[test]
3617    fn test_123() {
3618        let params = crate::config::endpoint::Params::builder()
3619            .region("aws-global".to_string())
3620            .bucket("bucket".to_string())
3621            .endpoint("http://192.168.1.1".to_string())
3622            .build()
3623            .expect("invalid params");
3624        let resolver = crate::config::endpoint::DefaultResolver::new();
3625        let endpoint = resolver.resolve_endpoint(&params);
3626        let endpoint = endpoint.expect("Expected valid endpoint: http://192.168.1.1/bucket");
3627        assert_eq!(
3628            endpoint,
3629            ::aws_smithy_types::endpoint::Endpoint::builder()
3630                .url("http://192.168.1.1/bucket")
3631                .property(
3632                    "authSchemes",
3633                    vec![{
3634                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3635                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3636                        out.insert("name".to_string(), "sigv4".to_string().into());
3637                        out.insert("signingName".to_string(), "s3".to_string().into());
3638                        out.insert("disableDoubleEncoding".to_string(), true.into());
3639                        out
3640                    }
3641                    .into()]
3642                )
3643                .build()
3644        );
3645    }
3646
3647    /// endpoint override with aws-global region
3648    #[test]
3649    fn test_124() {
3650        let params = crate::config::endpoint::Params::builder()
3651            .region("aws-global".to_string())
3652            .use_fips(true)
3653            .use_dual_stack(true)
3654            .endpoint("http://foo.com".to_string())
3655            .build()
3656            .expect("invalid params");
3657        let resolver = crate::config::endpoint::DefaultResolver::new();
3658        let endpoint = resolver.resolve_endpoint(&params);
3659        let error = endpoint
3660            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [endpoint override with aws-global region]");
3661        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3662    }
3663
3664    /// FIPS + path-only (TODO: consider making this an error)
3665    #[test]
3666    fn test_125() {
3667        let params = crate::config::endpoint::Params::builder()
3668            .region("aws-global".to_string())
3669            .bucket("bucket!".to_string())
3670            .use_fips(true)
3671            .build()
3672            .expect("invalid params");
3673        let resolver = crate::config::endpoint::DefaultResolver::new();
3674        let endpoint = resolver.resolve_endpoint(&params);
3675        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
3676        assert_eq!(
3677            endpoint,
3678            ::aws_smithy_types::endpoint::Endpoint::builder()
3679                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
3680                .property(
3681                    "authSchemes",
3682                    vec![{
3683                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3684                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3685                        out.insert("name".to_string(), "sigv4".to_string().into());
3686                        out.insert("signingName".to_string(), "s3".to_string().into());
3687                        out.insert("disableDoubleEncoding".to_string(), true.into());
3688                        out
3689                    }
3690                    .into()]
3691                )
3692                .build()
3693        );
3694    }
3695
3696    /// empty arn type
3697    #[test]
3698    fn test_126() {
3699        let params = crate::config::endpoint::Params::builder()
3700            .region("us-east-2".to_string())
3701            .bucket("arn:aws:not-s3:us-west-2:123456789012::myendpoint".to_string())
3702            .build()
3703            .expect("invalid params");
3704        let resolver = crate::config::endpoint::DefaultResolver::new();
3705        let endpoint = resolver.resolve_endpoint(&params);
3706        let error = endpoint.expect_err("expected error: Invalid ARN: No ARN type specified [empty arn type]");
3707        assert_eq!(format!("{}", error), "Invalid ARN: No ARN type specified")
3708    }
3709
3710    /// path style can't be used with accelerate
3711    #[test]
3712    fn test_127() {
3713        let params = crate::config::endpoint::Params::builder()
3714            .region("us-east-2".to_string())
3715            .bucket("bucket!".to_string())
3716            .accelerate(true)
3717            .build()
3718            .expect("invalid params");
3719        let resolver = crate::config::endpoint::DefaultResolver::new();
3720        let endpoint = resolver.resolve_endpoint(&params);
3721        let error =
3722            endpoint.expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style can't be used with accelerate]");
3723        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
3724    }
3725
3726    /// invalid region
3727    #[test]
3728    fn test_128() {
3729        let params = crate::config::endpoint::Params::builder()
3730            .region("us-east-2!".to_string())
3731            .bucket("bucket.subdomain".to_string())
3732            .endpoint("http://foo.com".to_string())
3733            .build()
3734            .expect("invalid params");
3735        let resolver = crate::config::endpoint::DefaultResolver::new();
3736        let endpoint = resolver.resolve_endpoint(&params);
3737        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [invalid region]");
3738        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
3739    }
3740
3741    /// invalid region
3742    #[test]
3743    fn test_129() {
3744        let params = crate::config::endpoint::Params::builder()
3745            .region("us-east-2!".to_string())
3746            .bucket("bucket".to_string())
3747            .endpoint("http://foo.com".to_string())
3748            .build()
3749            .expect("invalid params");
3750        let resolver = crate::config::endpoint::DefaultResolver::new();
3751        let endpoint = resolver.resolve_endpoint(&params);
3752        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [invalid region]");
3753        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
3754    }
3755
3756    /// empty arn type
3757    #[test]
3758    fn test_130() {
3759        let params = crate::config::endpoint::Params::builder()
3760            .region("us-east-2".to_string())
3761            .bucket("arn:aws:s3::123456789012:accesspoint:my_endpoint".to_string())
3762            .build()
3763            .expect("invalid params");
3764        let resolver = crate::config::endpoint::DefaultResolver::new();
3765        let endpoint = resolver.resolve_endpoint(&params);
3766        let error = endpoint.expect_err("expected error: Invalid Access Point Name [empty arn type]");
3767        assert_eq!(format!("{}", error), "Invalid Access Point Name")
3768    }
3769
3770    /// empty arn type
3771    #[test]
3772    fn test_131() {
3773        let params = crate::config::endpoint::Params::builder()
3774            .region("us-east-2".to_string())
3775            .bucket("arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint".to_string())
3776            .use_arn_region(true)
3777            .build()
3778            .expect("invalid params");
3779        let resolver = crate::config::endpoint::DefaultResolver::new();
3780        let endpoint = resolver.resolve_endpoint(&params);
3781        let error = endpoint.expect_err("expected error: Client was configured for partition `aws` but ARN (`arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint`) has `aws-cn` [empty arn type]");
3782        assert_eq!(
3783            format!("{}", error),
3784            "Client was configured for partition `aws` but ARN (`arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint`) has `aws-cn`"
3785        )
3786    }
3787
3788    /// invalid arn region
3789    #[test]
3790    fn test_132() {
3791        let params = crate::config::endpoint::Params::builder()
3792            .region("us-east-2".to_string())
3793            .bucket("arn:aws:s3-object-lambda:us-east_2:123456789012:accesspoint:my-endpoint".to_string())
3794            .use_arn_region(true)
3795            .build()
3796            .expect("invalid params");
3797        let resolver = crate::config::endpoint::DefaultResolver::new();
3798        let endpoint = resolver.resolve_endpoint(&params);
3799        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-east_2` (invalid DNS name) [invalid arn region]");
3800        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-east_2` (invalid DNS name)")
3801    }
3802
3803    /// invalid ARN outpost
3804    #[test]
3805    fn test_133() {
3806        let params = crate::config::endpoint::Params::builder()
3807            .region("us-east-2".to_string())
3808            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op_01234567890123456/accesspoint/reports".to_string())
3809            .use_arn_region(true)
3810            .build()
3811            .expect("invalid params");
3812        let resolver = crate::config::endpoint::DefaultResolver::new();
3813        let endpoint = resolver.resolve_endpoint(&params);
3814        let error = endpoint.expect_err(
3815            "expected error: Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `op_01234567890123456` [invalid ARN outpost]",
3816        );
3817        assert_eq!(
3818            format!("{}", error),
3819            "Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `op_01234567890123456`"
3820        )
3821    }
3822
3823    /// invalid ARN
3824    #[test]
3825    fn test_134() {
3826        let params = crate::config::endpoint::Params::builder()
3827            .region("us-east-2".to_string())
3828            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/reports".to_string())
3829            .build()
3830            .expect("invalid params");
3831        let resolver = crate::config::endpoint::DefaultResolver::new();
3832        let endpoint = resolver.resolve_endpoint(&params);
3833        let error = endpoint.expect_err("expected error: Invalid ARN: expected an access point name [invalid ARN]");
3834        assert_eq!(format!("{}", error), "Invalid ARN: expected an access point name")
3835    }
3836
3837    /// invalid ARN
3838    #[test]
3839    fn test_135() {
3840        let params = crate::config::endpoint::Params::builder()
3841            .region("us-east-2".to_string())
3842            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456".to_string())
3843            .build()
3844            .expect("invalid params");
3845        let resolver = crate::config::endpoint::DefaultResolver::new();
3846        let endpoint = resolver.resolve_endpoint(&params);
3847        let error = endpoint.expect_err("expected error: Invalid ARN: Expected a 4-component resource [invalid ARN]");
3848        assert_eq!(format!("{}", error), "Invalid ARN: Expected a 4-component resource")
3849    }
3850
3851    /// invalid outpost type
3852    #[test]
3853    fn test_136() {
3854        let params = crate::config::endpoint::Params::builder()
3855            .region("us-east-2".to_string())
3856            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3857            .build()
3858            .expect("invalid params");
3859        let resolver = crate::config::endpoint::DefaultResolver::new();
3860        let endpoint = resolver.resolve_endpoint(&params);
3861        let error = endpoint.expect_err("expected error: Expected an outpost type `accesspoint`, found not-accesspoint [invalid outpost type]");
3862        assert_eq!(format!("{}", error), "Expected an outpost type `accesspoint`, found not-accesspoint")
3863    }
3864
3865    /// invalid outpost type
3866    #[test]
3867    fn test_137() {
3868        let params = crate::config::endpoint::Params::builder()
3869            .region("us-east-2".to_string())
3870            .bucket("arn:aws:s3-outposts:us-east_1:123456789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3871            .build()
3872            .expect("invalid params");
3873        let resolver = crate::config::endpoint::DefaultResolver::new();
3874        let endpoint = resolver.resolve_endpoint(&params);
3875        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-east_1` (invalid DNS name) [invalid outpost type]");
3876        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-east_1` (invalid DNS name)")
3877    }
3878
3879    /// invalid outpost type
3880    #[test]
3881    fn test_138() {
3882        let params = crate::config::endpoint::Params::builder()
3883            .region("us-east-2".to_string())
3884            .bucket("arn:aws:s3-outposts:us-east-1:12345_789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3885            .build()
3886            .expect("invalid params");
3887        let resolver = crate::config::endpoint::DefaultResolver::new();
3888        let endpoint = resolver.resolve_endpoint(&params);
3889        let error = endpoint.expect_err(
3890            "expected error: Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `12345_789012` [invalid outpost type]",
3891        );
3892        assert_eq!(
3893            format!("{}", error),
3894            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `12345_789012`"
3895        )
3896    }
3897
3898    /// invalid outpost type
3899    #[test]
3900    fn test_139() {
3901        let params = crate::config::endpoint::Params::builder()
3902            .region("us-east-2".to_string())
3903            .bucket("arn:aws:s3-outposts:us-east-1:12345789012:outpost".to_string())
3904            .build()
3905            .expect("invalid params");
3906        let resolver = crate::config::endpoint::DefaultResolver::new();
3907        let endpoint = resolver.resolve_endpoint(&params);
3908        let error = endpoint.expect_err("expected error: Invalid ARN: The Outpost Id was not set [invalid outpost type]");
3909        assert_eq!(format!("{}", error), "Invalid ARN: The Outpost Id was not set")
3910    }
3911
3912    /// use global endpoint virtual addressing
3913    #[test]
3914    fn test_140() {
3915        let params = crate::config::endpoint::Params::builder()
3916            .region("us-east-2".to_string())
3917            .bucket("bucket".to_string())
3918            .endpoint("http://example.com".to_string())
3919            .use_global_endpoint(true)
3920            .build()
3921            .expect("invalid params");
3922        let resolver = crate::config::endpoint::DefaultResolver::new();
3923        let endpoint = resolver.resolve_endpoint(&params);
3924        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket.example.com");
3925        assert_eq!(
3926            endpoint,
3927            ::aws_smithy_types::endpoint::Endpoint::builder()
3928                .url("http://bucket.example.com")
3929                .property(
3930                    "authSchemes",
3931                    vec![{
3932                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3933                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3934                        out.insert("name".to_string(), "sigv4".to_string().into());
3935                        out.insert("signingName".to_string(), "s3".to_string().into());
3936                        out.insert("disableDoubleEncoding".to_string(), true.into());
3937                        out
3938                    }
3939                    .into()]
3940                )
3941                .build()
3942        );
3943    }
3944
3945    /// global endpoint + ip address
3946    #[test]
3947    fn test_141() {
3948        let params = crate::config::endpoint::Params::builder()
3949            .region("us-east-2".to_string())
3950            .bucket("bucket".to_string())
3951            .endpoint("http://192.168.0.1".to_string())
3952            .use_global_endpoint(true)
3953            .build()
3954            .expect("invalid params");
3955        let resolver = crate::config::endpoint::DefaultResolver::new();
3956        let endpoint = resolver.resolve_endpoint(&params);
3957        let endpoint = endpoint.expect("Expected valid endpoint: http://192.168.0.1/bucket");
3958        assert_eq!(
3959            endpoint,
3960            ::aws_smithy_types::endpoint::Endpoint::builder()
3961                .url("http://192.168.0.1/bucket")
3962                .property(
3963                    "authSchemes",
3964                    vec![{
3965                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3966                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3967                        out.insert("name".to_string(), "sigv4".to_string().into());
3968                        out.insert("signingName".to_string(), "s3".to_string().into());
3969                        out.insert("disableDoubleEncoding".to_string(), true.into());
3970                        out
3971                    }
3972                    .into()]
3973                )
3974                .build()
3975        );
3976    }
3977
3978    /// invalid outpost type
3979    #[test]
3980    fn test_142() {
3981        let params = crate::config::endpoint::Params::builder()
3982            .region("us-east-2".to_string())
3983            .bucket("bucket!".to_string())
3984            .use_global_endpoint(true)
3985            .build()
3986            .expect("invalid params");
3987        let resolver = crate::config::endpoint::DefaultResolver::new();
3988        let endpoint = resolver.resolve_endpoint(&params);
3989        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-2.amazonaws.com/bucket%21");
3990        assert_eq!(
3991            endpoint,
3992            ::aws_smithy_types::endpoint::Endpoint::builder()
3993                .url("https://s3.us-east-2.amazonaws.com/bucket%21")
3994                .property(
3995                    "authSchemes",
3996                    vec![{
3997                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3998                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3999                        out.insert("name".to_string(), "sigv4".to_string().into());
4000                        out.insert("signingName".to_string(), "s3".to_string().into());
4001                        out.insert("disableDoubleEncoding".to_string(), true.into());
4002                        out
4003                    }
4004                    .into()]
4005                )
4006                .build()
4007        );
4008    }
4009
4010    /// invalid outpost type
4011    #[test]
4012    fn test_143() {
4013        let params = crate::config::endpoint::Params::builder()
4014            .region("us-east-2".to_string())
4015            .bucket("bucket".to_string())
4016            .accelerate(true)
4017            .use_global_endpoint(true)
4018            .build()
4019            .expect("invalid params");
4020        let resolver = crate::config::endpoint::DefaultResolver::new();
4021        let endpoint = resolver.resolve_endpoint(&params);
4022        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.amazonaws.com");
4023        assert_eq!(
4024            endpoint,
4025            ::aws_smithy_types::endpoint::Endpoint::builder()
4026                .url("https://bucket.s3-accelerate.amazonaws.com")
4027                .property(
4028                    "authSchemes",
4029                    vec![{
4030                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4031                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
4032                        out.insert("name".to_string(), "sigv4".to_string().into());
4033                        out.insert("signingName".to_string(), "s3".to_string().into());
4034                        out.insert("disableDoubleEncoding".to_string(), true.into());
4035                        out
4036                    }
4037                    .into()]
4038                )
4039                .build()
4040        );
4041    }
4042
4043    /// use global endpoint + custom endpoint
4044    #[test]
4045    fn test_144() {
4046        let params = crate::config::endpoint::Params::builder()
4047            .region("us-east-2".to_string())
4048            .bucket("bucket!".to_string())
4049            .use_global_endpoint(true)
4050            .endpoint("http://foo.com".to_string())
4051            .build()
4052            .expect("invalid params");
4053        let resolver = crate::config::endpoint::DefaultResolver::new();
4054        let endpoint = resolver.resolve_endpoint(&params);
4055        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
4056        assert_eq!(
4057            endpoint,
4058            ::aws_smithy_types::endpoint::Endpoint::builder()
4059                .url("http://foo.com/bucket%21")
4060                .property(
4061                    "authSchemes",
4062                    vec![{
4063                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4064                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
4065                        out.insert("name".to_string(), "sigv4".to_string().into());
4066                        out.insert("signingName".to_string(), "s3".to_string().into());
4067                        out.insert("disableDoubleEncoding".to_string(), true.into());
4068                        out
4069                    }
4070                    .into()]
4071                )
4072                .build()
4073        );
4074    }
4075
4076    /// use global endpoint, not us-east-1, force path style
4077    #[test]
4078    fn test_145() {
4079        let params = crate::config::endpoint::Params::builder()
4080            .region("us-east-2".to_string())
4081            .bucket("bucket!".to_string())
4082            .use_global_endpoint(true)
4083            .force_path_style(true)
4084            .endpoint("http://foo.com".to_string())
4085            .build()
4086            .expect("invalid params");
4087        let resolver = crate::config::endpoint::DefaultResolver::new();
4088        let endpoint = resolver.resolve_endpoint(&params);
4089        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
4090        assert_eq!(
4091            endpoint,
4092            ::aws_smithy_types::endpoint::Endpoint::builder()
4093                .url("http://foo.com/bucket%21")
4094                .property(
4095                    "authSchemes",
4096                    vec![{
4097                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4098                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
4099                        out.insert("name".to_string(), "sigv4".to_string().into());
4100                        out.insert("signingName".to_string(), "s3".to_string().into());
4101                        out.insert("disableDoubleEncoding".to_string(), true.into());
4102                        out
4103                    }
4104                    .into()]
4105                )
4106                .build()
4107        );
4108    }
4109
4110    /// vanilla virtual addressing@us-west-2
4111    #[test]
4112    fn test_146() {
4113        let params = crate::config::endpoint::Params::builder()
4114            .accelerate(false)
4115            .bucket("bucket-name".to_string())
4116            .force_path_style(false)
4117            .region("us-west-2".to_string())
4118            .use_dual_stack(false)
4119            .use_fips(false)
4120            .build()
4121            .expect("invalid params");
4122        let resolver = crate::config::endpoint::DefaultResolver::new();
4123        let endpoint = resolver.resolve_endpoint(&params);
4124        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.us-west-2.amazonaws.com");
4125        assert_eq!(
4126            endpoint,
4127            ::aws_smithy_types::endpoint::Endpoint::builder()
4128                .url("https://bucket-name.s3.us-west-2.amazonaws.com")
4129                .property(
4130                    "authSchemes",
4131                    vec![{
4132                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4133                        out.insert("name".to_string(), "sigv4".to_string().into());
4134                        out.insert("signingName".to_string(), "s3".to_string().into());
4135                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4136                        out.insert("disableDoubleEncoding".to_string(), true.into());
4137                        out
4138                    }
4139                    .into()]
4140                )
4141                .build()
4142        );
4143    }
4144
4145    /// virtual addressing + dualstack@us-west-2
4146    #[test]
4147    fn test_147() {
4148        let params = crate::config::endpoint::Params::builder()
4149            .accelerate(false)
4150            .bucket("bucket-name".to_string())
4151            .force_path_style(false)
4152            .region("us-west-2".to_string())
4153            .use_dual_stack(true)
4154            .use_fips(false)
4155            .build()
4156            .expect("invalid params");
4157        let resolver = crate::config::endpoint::DefaultResolver::new();
4158        let endpoint = resolver.resolve_endpoint(&params);
4159        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-west-2.amazonaws.com");
4160        assert_eq!(
4161            endpoint,
4162            ::aws_smithy_types::endpoint::Endpoint::builder()
4163                .url("https://bucket-name.s3.dualstack.us-west-2.amazonaws.com")
4164                .property(
4165                    "authSchemes",
4166                    vec![{
4167                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4168                        out.insert("name".to_string(), "sigv4".to_string().into());
4169                        out.insert("signingName".to_string(), "s3".to_string().into());
4170                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4171                        out.insert("disableDoubleEncoding".to_string(), true.into());
4172                        out
4173                    }
4174                    .into()]
4175                )
4176                .build()
4177        );
4178    }
4179
4180    /// accelerate + dualstack@us-west-2
4181    #[test]
4182    fn test_148() {
4183        let params = crate::config::endpoint::Params::builder()
4184            .accelerate(true)
4185            .bucket("bucket-name".to_string())
4186            .force_path_style(false)
4187            .region("us-west-2".to_string())
4188            .use_dual_stack(true)
4189            .use_fips(false)
4190            .build()
4191            .expect("invalid params");
4192        let resolver = crate::config::endpoint::DefaultResolver::new();
4193        let endpoint = resolver.resolve_endpoint(&params);
4194        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.dualstack.amazonaws.com");
4195        assert_eq!(
4196            endpoint,
4197            ::aws_smithy_types::endpoint::Endpoint::builder()
4198                .url("https://bucket-name.s3-accelerate.dualstack.amazonaws.com")
4199                .property(
4200                    "authSchemes",
4201                    vec![{
4202                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4203                        out.insert("name".to_string(), "sigv4".to_string().into());
4204                        out.insert("signingName".to_string(), "s3".to_string().into());
4205                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4206                        out.insert("disableDoubleEncoding".to_string(), true.into());
4207                        out
4208                    }
4209                    .into()]
4210                )
4211                .build()
4212        );
4213    }
4214
4215    /// accelerate (dualstack=false)@us-west-2
4216    #[test]
4217    fn test_149() {
4218        let params = crate::config::endpoint::Params::builder()
4219            .accelerate(true)
4220            .bucket("bucket-name".to_string())
4221            .force_path_style(false)
4222            .region("us-west-2".to_string())
4223            .use_dual_stack(false)
4224            .use_fips(false)
4225            .build()
4226            .expect("invalid params");
4227        let resolver = crate::config::endpoint::DefaultResolver::new();
4228        let endpoint = resolver.resolve_endpoint(&params);
4229        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
4230        assert_eq!(
4231            endpoint,
4232            ::aws_smithy_types::endpoint::Endpoint::builder()
4233                .url("https://bucket-name.s3-accelerate.amazonaws.com")
4234                .property(
4235                    "authSchemes",
4236                    vec![{
4237                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4238                        out.insert("name".to_string(), "sigv4".to_string().into());
4239                        out.insert("signingName".to_string(), "s3".to_string().into());
4240                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4241                        out.insert("disableDoubleEncoding".to_string(), true.into());
4242                        out
4243                    }
4244                    .into()]
4245                )
4246                .build()
4247        );
4248    }
4249
4250    /// virtual addressing + fips@us-west-2
4251    #[test]
4252    fn test_150() {
4253        let params = crate::config::endpoint::Params::builder()
4254            .accelerate(false)
4255            .bucket("bucket-name".to_string())
4256            .force_path_style(false)
4257            .region("us-west-2".to_string())
4258            .use_dual_stack(false)
4259            .use_fips(true)
4260            .build()
4261            .expect("invalid params");
4262        let resolver = crate::config::endpoint::DefaultResolver::new();
4263        let endpoint = resolver.resolve_endpoint(&params);
4264        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-west-2.amazonaws.com");
4265        assert_eq!(
4266            endpoint,
4267            ::aws_smithy_types::endpoint::Endpoint::builder()
4268                .url("https://bucket-name.s3-fips.us-west-2.amazonaws.com")
4269                .property(
4270                    "authSchemes",
4271                    vec![{
4272                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4273                        out.insert("name".to_string(), "sigv4".to_string().into());
4274                        out.insert("signingName".to_string(), "s3".to_string().into());
4275                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4276                        out.insert("disableDoubleEncoding".to_string(), true.into());
4277                        out
4278                    }
4279                    .into()]
4280                )
4281                .build()
4282        );
4283    }
4284
4285    /// virtual addressing + dualstack + fips@us-west-2
4286    #[test]
4287    fn test_151() {
4288        let params = crate::config::endpoint::Params::builder()
4289            .accelerate(false)
4290            .bucket("bucket-name".to_string())
4291            .force_path_style(false)
4292            .region("us-west-2".to_string())
4293            .use_dual_stack(true)
4294            .use_fips(true)
4295            .build()
4296            .expect("invalid params");
4297        let resolver = crate::config::endpoint::DefaultResolver::new();
4298        let endpoint = resolver.resolve_endpoint(&params);
4299        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.us-west-2.amazonaws.com");
4300        assert_eq!(
4301            endpoint,
4302            ::aws_smithy_types::endpoint::Endpoint::builder()
4303                .url("https://bucket-name.s3-fips.dualstack.us-west-2.amazonaws.com")
4304                .property(
4305                    "authSchemes",
4306                    vec![{
4307                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4308                        out.insert("name".to_string(), "sigv4".to_string().into());
4309                        out.insert("signingName".to_string(), "s3".to_string().into());
4310                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4311                        out.insert("disableDoubleEncoding".to_string(), true.into());
4312                        out
4313                    }
4314                    .into()]
4315                )
4316                .build()
4317        );
4318    }
4319
4320    /// accelerate + fips = error@us-west-2
4321    #[test]
4322    fn test_152() {
4323        let params = crate::config::endpoint::Params::builder()
4324            .accelerate(true)
4325            .bucket("bucket-name".to_string())
4326            .force_path_style(false)
4327            .region("us-west-2".to_string())
4328            .use_dual_stack(false)
4329            .use_fips(true)
4330            .build()
4331            .expect("invalid params");
4332        let resolver = crate::config::endpoint::DefaultResolver::new();
4333        let endpoint = resolver.resolve_endpoint(&params);
4334        let error = endpoint.expect_err("expected error: Accelerate cannot be used with FIPS [accelerate + fips = error@us-west-2]");
4335        assert_eq!(format!("{}", error), "Accelerate cannot be used with FIPS")
4336    }
4337
4338    /// vanilla virtual addressing@cn-north-1
4339    #[test]
4340    fn test_153() {
4341        let params = crate::config::endpoint::Params::builder()
4342            .accelerate(false)
4343            .bucket("bucket-name".to_string())
4344            .force_path_style(false)
4345            .region("cn-north-1".to_string())
4346            .use_dual_stack(false)
4347            .use_fips(false)
4348            .build()
4349            .expect("invalid params");
4350        let resolver = crate::config::endpoint::DefaultResolver::new();
4351        let endpoint = resolver.resolve_endpoint(&params);
4352        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.cn-north-1.amazonaws.com.cn");
4353        assert_eq!(
4354            endpoint,
4355            ::aws_smithy_types::endpoint::Endpoint::builder()
4356                .url("https://bucket-name.s3.cn-north-1.amazonaws.com.cn")
4357                .property(
4358                    "authSchemes",
4359                    vec![{
4360                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4361                        out.insert("name".to_string(), "sigv4".to_string().into());
4362                        out.insert("signingName".to_string(), "s3".to_string().into());
4363                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4364                        out.insert("disableDoubleEncoding".to_string(), true.into());
4365                        out
4366                    }
4367                    .into()]
4368                )
4369                .build()
4370        );
4371    }
4372
4373    /// virtual addressing + dualstack@cn-north-1
4374    #[test]
4375    fn test_154() {
4376        let params = crate::config::endpoint::Params::builder()
4377            .accelerate(false)
4378            .bucket("bucket-name".to_string())
4379            .force_path_style(false)
4380            .region("cn-north-1".to_string())
4381            .use_dual_stack(true)
4382            .use_fips(false)
4383            .build()
4384            .expect("invalid params");
4385        let resolver = crate::config::endpoint::DefaultResolver::new();
4386        let endpoint = resolver.resolve_endpoint(&params);
4387        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.cn-north-1.amazonaws.com.cn");
4388        assert_eq!(
4389            endpoint,
4390            ::aws_smithy_types::endpoint::Endpoint::builder()
4391                .url("https://bucket-name.s3.dualstack.cn-north-1.amazonaws.com.cn")
4392                .property(
4393                    "authSchemes",
4394                    vec![{
4395                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4396                        out.insert("name".to_string(), "sigv4".to_string().into());
4397                        out.insert("signingName".to_string(), "s3".to_string().into());
4398                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4399                        out.insert("disableDoubleEncoding".to_string(), true.into());
4400                        out
4401                    }
4402                    .into()]
4403                )
4404                .build()
4405        );
4406    }
4407
4408    /// accelerate (dualstack=false)@cn-north-1
4409    #[test]
4410    fn test_155() {
4411        let params = crate::config::endpoint::Params::builder()
4412            .accelerate(true)
4413            .bucket("bucket-name".to_string())
4414            .force_path_style(false)
4415            .region("cn-north-1".to_string())
4416            .use_dual_stack(false)
4417            .use_fips(false)
4418            .build()
4419            .expect("invalid params");
4420        let resolver = crate::config::endpoint::DefaultResolver::new();
4421        let endpoint = resolver.resolve_endpoint(&params);
4422        let error = endpoint.expect_err("expected error: S3 Accelerate cannot be used in this region [accelerate (dualstack=false)@cn-north-1]");
4423        assert_eq!(format!("{}", error), "S3 Accelerate cannot be used in this region")
4424    }
4425
4426    /// virtual addressing + fips@cn-north-1
4427    #[test]
4428    fn test_156() {
4429        let params = crate::config::endpoint::Params::builder()
4430            .accelerate(false)
4431            .bucket("bucket-name".to_string())
4432            .force_path_style(false)
4433            .region("cn-north-1".to_string())
4434            .use_dual_stack(false)
4435            .use_fips(true)
4436            .build()
4437            .expect("invalid params");
4438        let resolver = crate::config::endpoint::DefaultResolver::new();
4439        let endpoint = resolver.resolve_endpoint(&params);
4440        let error = endpoint.expect_err("expected error: Partition does not support FIPS [virtual addressing + fips@cn-north-1]");
4441        assert_eq!(format!("{}", error), "Partition does not support FIPS")
4442    }
4443
4444    /// vanilla virtual addressing@af-south-1
4445    #[test]
4446    fn test_157() {
4447        let params = crate::config::endpoint::Params::builder()
4448            .accelerate(false)
4449            .bucket("bucket-name".to_string())
4450            .force_path_style(false)
4451            .region("af-south-1".to_string())
4452            .use_dual_stack(false)
4453            .use_fips(false)
4454            .build()
4455            .expect("invalid params");
4456        let resolver = crate::config::endpoint::DefaultResolver::new();
4457        let endpoint = resolver.resolve_endpoint(&params);
4458        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.af-south-1.amazonaws.com");
4459        assert_eq!(
4460            endpoint,
4461            ::aws_smithy_types::endpoint::Endpoint::builder()
4462                .url("https://bucket-name.s3.af-south-1.amazonaws.com")
4463                .property(
4464                    "authSchemes",
4465                    vec![{
4466                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4467                        out.insert("name".to_string(), "sigv4".to_string().into());
4468                        out.insert("signingName".to_string(), "s3".to_string().into());
4469                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4470                        out.insert("disableDoubleEncoding".to_string(), true.into());
4471                        out
4472                    }
4473                    .into()]
4474                )
4475                .build()
4476        );
4477    }
4478
4479    /// virtual addressing + dualstack@af-south-1
4480    #[test]
4481    fn test_158() {
4482        let params = crate::config::endpoint::Params::builder()
4483            .accelerate(false)
4484            .bucket("bucket-name".to_string())
4485            .force_path_style(false)
4486            .region("af-south-1".to_string())
4487            .use_dual_stack(true)
4488            .use_fips(false)
4489            .build()
4490            .expect("invalid params");
4491        let resolver = crate::config::endpoint::DefaultResolver::new();
4492        let endpoint = resolver.resolve_endpoint(&params);
4493        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.af-south-1.amazonaws.com");
4494        assert_eq!(
4495            endpoint,
4496            ::aws_smithy_types::endpoint::Endpoint::builder()
4497                .url("https://bucket-name.s3.dualstack.af-south-1.amazonaws.com")
4498                .property(
4499                    "authSchemes",
4500                    vec![{
4501                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4502                        out.insert("name".to_string(), "sigv4".to_string().into());
4503                        out.insert("signingName".to_string(), "s3".to_string().into());
4504                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4505                        out.insert("disableDoubleEncoding".to_string(), true.into());
4506                        out
4507                    }
4508                    .into()]
4509                )
4510                .build()
4511        );
4512    }
4513
4514    /// accelerate + dualstack@af-south-1
4515    #[test]
4516    fn test_159() {
4517        let params = crate::config::endpoint::Params::builder()
4518            .accelerate(true)
4519            .bucket("bucket-name".to_string())
4520            .force_path_style(false)
4521            .region("af-south-1".to_string())
4522            .use_dual_stack(true)
4523            .use_fips(false)
4524            .build()
4525            .expect("invalid params");
4526        let resolver = crate::config::endpoint::DefaultResolver::new();
4527        let endpoint = resolver.resolve_endpoint(&params);
4528        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.dualstack.amazonaws.com");
4529        assert_eq!(
4530            endpoint,
4531            ::aws_smithy_types::endpoint::Endpoint::builder()
4532                .url("https://bucket-name.s3-accelerate.dualstack.amazonaws.com")
4533                .property(
4534                    "authSchemes",
4535                    vec![{
4536                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4537                        out.insert("name".to_string(), "sigv4".to_string().into());
4538                        out.insert("signingName".to_string(), "s3".to_string().into());
4539                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4540                        out.insert("disableDoubleEncoding".to_string(), true.into());
4541                        out
4542                    }
4543                    .into()]
4544                )
4545                .build()
4546        );
4547    }
4548
4549    /// accelerate (dualstack=false)@af-south-1
4550    #[test]
4551    fn test_160() {
4552        let params = crate::config::endpoint::Params::builder()
4553            .accelerate(true)
4554            .bucket("bucket-name".to_string())
4555            .force_path_style(false)
4556            .region("af-south-1".to_string())
4557            .use_dual_stack(false)
4558            .use_fips(false)
4559            .build()
4560            .expect("invalid params");
4561        let resolver = crate::config::endpoint::DefaultResolver::new();
4562        let endpoint = resolver.resolve_endpoint(&params);
4563        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
4564        assert_eq!(
4565            endpoint,
4566            ::aws_smithy_types::endpoint::Endpoint::builder()
4567                .url("https://bucket-name.s3-accelerate.amazonaws.com")
4568                .property(
4569                    "authSchemes",
4570                    vec![{
4571                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4572                        out.insert("name".to_string(), "sigv4".to_string().into());
4573                        out.insert("signingName".to_string(), "s3".to_string().into());
4574                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4575                        out.insert("disableDoubleEncoding".to_string(), true.into());
4576                        out
4577                    }
4578                    .into()]
4579                )
4580                .build()
4581        );
4582    }
4583
4584    /// virtual addressing + fips@af-south-1
4585    #[test]
4586    fn test_161() {
4587        let params = crate::config::endpoint::Params::builder()
4588            .accelerate(false)
4589            .bucket("bucket-name".to_string())
4590            .force_path_style(false)
4591            .region("af-south-1".to_string())
4592            .use_dual_stack(false)
4593            .use_fips(true)
4594            .build()
4595            .expect("invalid params");
4596        let resolver = crate::config::endpoint::DefaultResolver::new();
4597        let endpoint = resolver.resolve_endpoint(&params);
4598        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.af-south-1.amazonaws.com");
4599        assert_eq!(
4600            endpoint,
4601            ::aws_smithy_types::endpoint::Endpoint::builder()
4602                .url("https://bucket-name.s3-fips.af-south-1.amazonaws.com")
4603                .property(
4604                    "authSchemes",
4605                    vec![{
4606                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4607                        out.insert("name".to_string(), "sigv4".to_string().into());
4608                        out.insert("signingName".to_string(), "s3".to_string().into());
4609                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4610                        out.insert("disableDoubleEncoding".to_string(), true.into());
4611                        out
4612                    }
4613                    .into()]
4614                )
4615                .build()
4616        );
4617    }
4618
4619    /// virtual addressing + dualstack + fips@af-south-1
4620    #[test]
4621    fn test_162() {
4622        let params = crate::config::endpoint::Params::builder()
4623            .accelerate(false)
4624            .bucket("bucket-name".to_string())
4625            .force_path_style(false)
4626            .region("af-south-1".to_string())
4627            .use_dual_stack(true)
4628            .use_fips(true)
4629            .build()
4630            .expect("invalid params");
4631        let resolver = crate::config::endpoint::DefaultResolver::new();
4632        let endpoint = resolver.resolve_endpoint(&params);
4633        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.af-south-1.amazonaws.com");
4634        assert_eq!(
4635            endpoint,
4636            ::aws_smithy_types::endpoint::Endpoint::builder()
4637                .url("https://bucket-name.s3-fips.dualstack.af-south-1.amazonaws.com")
4638                .property(
4639                    "authSchemes",
4640                    vec![{
4641                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4642                        out.insert("name".to_string(), "sigv4".to_string().into());
4643                        out.insert("signingName".to_string(), "s3".to_string().into());
4644                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4645                        out.insert("disableDoubleEncoding".to_string(), true.into());
4646                        out
4647                    }
4648                    .into()]
4649                )
4650                .build()
4651        );
4652    }
4653
4654    /// accelerate + fips = error@af-south-1
4655    #[test]
4656    fn test_163() {
4657        let params = crate::config::endpoint::Params::builder()
4658            .accelerate(true)
4659            .bucket("bucket-name".to_string())
4660            .force_path_style(false)
4661            .region("af-south-1".to_string())
4662            .use_dual_stack(false)
4663            .use_fips(true)
4664            .build()
4665            .expect("invalid params");
4666        let resolver = crate::config::endpoint::DefaultResolver::new();
4667        let endpoint = resolver.resolve_endpoint(&params);
4668        let error = endpoint.expect_err("expected error: Accelerate cannot be used with FIPS [accelerate + fips = error@af-south-1]");
4669        assert_eq!(format!("{}", error), "Accelerate cannot be used with FIPS")
4670    }
4671
4672    /// vanilla path style@us-west-2
4673    #[test]
4674    fn test_164() {
4675        let params = crate::config::endpoint::Params::builder()
4676            .accelerate(false)
4677            .bucket("bucket-name".to_string())
4678            .force_path_style(true)
4679            .region("us-west-2".to_string())
4680            .use_dual_stack(false)
4681            .use_fips(false)
4682            .build()
4683            .expect("invalid params");
4684        let resolver = crate::config::endpoint::DefaultResolver::new();
4685        let endpoint = resolver.resolve_endpoint(&params);
4686        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket-name");
4687        assert_eq!(
4688            endpoint,
4689            ::aws_smithy_types::endpoint::Endpoint::builder()
4690                .url("https://s3.us-west-2.amazonaws.com/bucket-name")
4691                .property(
4692                    "authSchemes",
4693                    vec![{
4694                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4695                        out.insert("name".to_string(), "sigv4".to_string().into());
4696                        out.insert("signingName".to_string(), "s3".to_string().into());
4697                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4698                        out.insert("disableDoubleEncoding".to_string(), true.into());
4699                        out
4700                    }
4701                    .into()]
4702                )
4703                .build()
4704        );
4705    }
4706
4707    /// fips@us-gov-west-2, bucket is not S3-dns-compatible (subdomains)
4708    #[test]
4709    fn test_165() {
4710        let params = crate::config::endpoint::Params::builder()
4711            .accelerate(false)
4712            .bucket("bucket.with.dots".to_string())
4713            .region("us-gov-west-1".to_string())
4714            .use_dual_stack(false)
4715            .use_fips(true)
4716            .build()
4717            .expect("invalid params");
4718        let resolver = crate::config::endpoint::DefaultResolver::new();
4719        let endpoint = resolver.resolve_endpoint(&params);
4720        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-gov-west-1.amazonaws.com/bucket.with.dots");
4721        assert_eq!(
4722            endpoint,
4723            ::aws_smithy_types::endpoint::Endpoint::builder()
4724                .url("https://s3-fips.us-gov-west-1.amazonaws.com/bucket.with.dots")
4725                .property(
4726                    "authSchemes",
4727                    vec![{
4728                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4729                        out.insert("signingName".to_string(), "s3".to_string().into());
4730                        out.insert("signingRegion".to_string(), "us-gov-west-1".to_string().into());
4731                        out.insert("disableDoubleEncoding".to_string(), true.into());
4732                        out.insert("name".to_string(), "sigv4".to_string().into());
4733                        out
4734                    }
4735                    .into()]
4736                )
4737                .build()
4738        );
4739    }
4740
4741    /// path style + accelerate = error@us-west-2
4742    #[test]
4743    fn test_166() {
4744        let params = crate::config::endpoint::Params::builder()
4745            .accelerate(true)
4746            .bucket("bucket-name".to_string())
4747            .force_path_style(true)
4748            .region("us-west-2".to_string())
4749            .use_dual_stack(false)
4750            .use_fips(false)
4751            .build()
4752            .expect("invalid params");
4753        let resolver = crate::config::endpoint::DefaultResolver::new();
4754        let endpoint = resolver.resolve_endpoint(&params);
4755        let error = endpoint
4756            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@us-west-2]");
4757        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
4758    }
4759
4760    /// path style + dualstack@us-west-2
4761    #[test]
4762    fn test_167() {
4763        let params = crate::config::endpoint::Params::builder()
4764            .accelerate(false)
4765            .bucket("bucket-name".to_string())
4766            .force_path_style(true)
4767            .region("us-west-2".to_string())
4768            .use_dual_stack(true)
4769            .use_fips(false)
4770            .build()
4771            .expect("invalid params");
4772        let resolver = crate::config::endpoint::DefaultResolver::new();
4773        let endpoint = resolver.resolve_endpoint(&params);
4774        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/bucket-name");
4775        assert_eq!(
4776            endpoint,
4777            ::aws_smithy_types::endpoint::Endpoint::builder()
4778                .url("https://s3.dualstack.us-west-2.amazonaws.com/bucket-name")
4779                .property(
4780                    "authSchemes",
4781                    vec![{
4782                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4783                        out.insert("name".to_string(), "sigv4".to_string().into());
4784                        out.insert("signingName".to_string(), "s3".to_string().into());
4785                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4786                        out.insert("disableDoubleEncoding".to_string(), true.into());
4787                        out
4788                    }
4789                    .into()]
4790                )
4791                .build()
4792        );
4793    }
4794
4795    /// path style + arn is error@us-west-2
4796    #[test]
4797    fn test_168() {
4798        let params = crate::config::endpoint::Params::builder()
4799            .accelerate(false)
4800            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
4801            .force_path_style(true)
4802            .region("us-west-2".to_string())
4803            .use_dual_stack(false)
4804            .use_fips(false)
4805            .build()
4806            .expect("invalid params");
4807        let resolver = crate::config::endpoint::DefaultResolver::new();
4808        let endpoint = resolver.resolve_endpoint(&params);
4809        let error =
4810            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@us-west-2]");
4811        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
4812    }
4813
4814    /// path style + invalid DNS name@us-west-2
4815    #[test]
4816    fn test_169() {
4817        let params = crate::config::endpoint::Params::builder()
4818            .accelerate(false)
4819            .bucket("99a_b".to_string())
4820            .force_path_style(true)
4821            .region("us-west-2".to_string())
4822            .use_dual_stack(false)
4823            .use_fips(false)
4824            .build()
4825            .expect("invalid params");
4826        let resolver = crate::config::endpoint::DefaultResolver::new();
4827        let endpoint = resolver.resolve_endpoint(&params);
4828        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/99a_b");
4829        assert_eq!(
4830            endpoint,
4831            ::aws_smithy_types::endpoint::Endpoint::builder()
4832                .url("https://s3.us-west-2.amazonaws.com/99a_b")
4833                .property(
4834                    "authSchemes",
4835                    vec![{
4836                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4837                        out.insert("name".to_string(), "sigv4".to_string().into());
4838                        out.insert("signingName".to_string(), "s3".to_string().into());
4839                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4840                        out.insert("disableDoubleEncoding".to_string(), true.into());
4841                        out
4842                    }
4843                    .into()]
4844                )
4845                .build()
4846        );
4847    }
4848
4849    /// no path style + invalid DNS name@us-west-2
4850    #[test]
4851    fn test_170() {
4852        let params = crate::config::endpoint::Params::builder()
4853            .accelerate(false)
4854            .bucket("99a_b".to_string())
4855            .region("us-west-2".to_string())
4856            .use_dual_stack(false)
4857            .use_fips(false)
4858            .build()
4859            .expect("invalid params");
4860        let resolver = crate::config::endpoint::DefaultResolver::new();
4861        let endpoint = resolver.resolve_endpoint(&params);
4862        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/99a_b");
4863        assert_eq!(
4864            endpoint,
4865            ::aws_smithy_types::endpoint::Endpoint::builder()
4866                .url("https://s3.us-west-2.amazonaws.com/99a_b")
4867                .property(
4868                    "authSchemes",
4869                    vec![{
4870                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4871                        out.insert("name".to_string(), "sigv4".to_string().into());
4872                        out.insert("signingName".to_string(), "s3".to_string().into());
4873                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4874                        out.insert("disableDoubleEncoding".to_string(), true.into());
4875                        out
4876                    }
4877                    .into()]
4878                )
4879                .build()
4880        );
4881    }
4882
4883    /// vanilla path style@cn-north-1
4884    #[test]
4885    fn test_171() {
4886        let params = crate::config::endpoint::Params::builder()
4887            .accelerate(false)
4888            .bucket("bucket-name".to_string())
4889            .force_path_style(true)
4890            .region("cn-north-1".to_string())
4891            .use_dual_stack(false)
4892            .use_fips(false)
4893            .build()
4894            .expect("invalid params");
4895        let resolver = crate::config::endpoint::DefaultResolver::new();
4896        let endpoint = resolver.resolve_endpoint(&params);
4897        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/bucket-name");
4898        assert_eq!(
4899            endpoint,
4900            ::aws_smithy_types::endpoint::Endpoint::builder()
4901                .url("https://s3.cn-north-1.amazonaws.com.cn/bucket-name")
4902                .property(
4903                    "authSchemes",
4904                    vec![{
4905                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4906                        out.insert("name".to_string(), "sigv4".to_string().into());
4907                        out.insert("signingName".to_string(), "s3".to_string().into());
4908                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4909                        out.insert("disableDoubleEncoding".to_string(), true.into());
4910                        out
4911                    }
4912                    .into()]
4913                )
4914                .build()
4915        );
4916    }
4917
4918    /// path style + fips@cn-north-1
4919    #[test]
4920    fn test_172() {
4921        let params = crate::config::endpoint::Params::builder()
4922            .accelerate(false)
4923            .bucket("bucket-name".to_string())
4924            .force_path_style(true)
4925            .region("cn-north-1".to_string())
4926            .use_dual_stack(false)
4927            .use_fips(true)
4928            .build()
4929            .expect("invalid params");
4930        let resolver = crate::config::endpoint::DefaultResolver::new();
4931        let endpoint = resolver.resolve_endpoint(&params);
4932        let error = endpoint.expect_err("expected error: Partition does not support FIPS [path style + fips@cn-north-1]");
4933        assert_eq!(format!("{}", error), "Partition does not support FIPS")
4934    }
4935
4936    /// path style + accelerate = error@cn-north-1
4937    #[test]
4938    fn test_173() {
4939        let params = crate::config::endpoint::Params::builder()
4940            .accelerate(true)
4941            .bucket("bucket-name".to_string())
4942            .force_path_style(true)
4943            .region("cn-north-1".to_string())
4944            .use_dual_stack(false)
4945            .use_fips(false)
4946            .build()
4947            .expect("invalid params");
4948        let resolver = crate::config::endpoint::DefaultResolver::new();
4949        let endpoint = resolver.resolve_endpoint(&params);
4950        let error = endpoint
4951            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@cn-north-1]");
4952        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
4953    }
4954
4955    /// path style + dualstack@cn-north-1
4956    #[test]
4957    fn test_174() {
4958        let params = crate::config::endpoint::Params::builder()
4959            .accelerate(false)
4960            .bucket("bucket-name".to_string())
4961            .force_path_style(true)
4962            .region("cn-north-1".to_string())
4963            .use_dual_stack(true)
4964            .use_fips(false)
4965            .build()
4966            .expect("invalid params");
4967        let resolver = crate::config::endpoint::DefaultResolver::new();
4968        let endpoint = resolver.resolve_endpoint(&params);
4969        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.cn-north-1.amazonaws.com.cn/bucket-name");
4970        assert_eq!(
4971            endpoint,
4972            ::aws_smithy_types::endpoint::Endpoint::builder()
4973                .url("https://s3.dualstack.cn-north-1.amazonaws.com.cn/bucket-name")
4974                .property(
4975                    "authSchemes",
4976                    vec![{
4977                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4978                        out.insert("name".to_string(), "sigv4".to_string().into());
4979                        out.insert("signingName".to_string(), "s3".to_string().into());
4980                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4981                        out.insert("disableDoubleEncoding".to_string(), true.into());
4982                        out
4983                    }
4984                    .into()]
4985                )
4986                .build()
4987        );
4988    }
4989
4990    /// path style + arn is error@cn-north-1
4991    #[test]
4992    fn test_175() {
4993        let params = crate::config::endpoint::Params::builder()
4994            .accelerate(false)
4995            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
4996            .force_path_style(true)
4997            .region("cn-north-1".to_string())
4998            .use_dual_stack(false)
4999            .use_fips(false)
5000            .build()
5001            .expect("invalid params");
5002        let resolver = crate::config::endpoint::DefaultResolver::new();
5003        let endpoint = resolver.resolve_endpoint(&params);
5004        let error =
5005            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@cn-north-1]");
5006        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
5007    }
5008
5009    /// path style + invalid DNS name@cn-north-1
5010    #[test]
5011    fn test_176() {
5012        let params = crate::config::endpoint::Params::builder()
5013            .accelerate(false)
5014            .bucket("99a_b".to_string())
5015            .force_path_style(true)
5016            .region("cn-north-1".to_string())
5017            .use_dual_stack(false)
5018            .use_fips(false)
5019            .build()
5020            .expect("invalid params");
5021        let resolver = crate::config::endpoint::DefaultResolver::new();
5022        let endpoint = resolver.resolve_endpoint(&params);
5023        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/99a_b");
5024        assert_eq!(
5025            endpoint,
5026            ::aws_smithy_types::endpoint::Endpoint::builder()
5027                .url("https://s3.cn-north-1.amazonaws.com.cn/99a_b")
5028                .property(
5029                    "authSchemes",
5030                    vec![{
5031                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5032                        out.insert("name".to_string(), "sigv4".to_string().into());
5033                        out.insert("signingName".to_string(), "s3".to_string().into());
5034                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5035                        out.insert("disableDoubleEncoding".to_string(), true.into());
5036                        out
5037                    }
5038                    .into()]
5039                )
5040                .build()
5041        );
5042    }
5043
5044    /// no path style + invalid DNS name@cn-north-1
5045    #[test]
5046    fn test_177() {
5047        let params = crate::config::endpoint::Params::builder()
5048            .accelerate(false)
5049            .bucket("99a_b".to_string())
5050            .region("cn-north-1".to_string())
5051            .use_dual_stack(false)
5052            .use_fips(false)
5053            .build()
5054            .expect("invalid params");
5055        let resolver = crate::config::endpoint::DefaultResolver::new();
5056        let endpoint = resolver.resolve_endpoint(&params);
5057        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/99a_b");
5058        assert_eq!(
5059            endpoint,
5060            ::aws_smithy_types::endpoint::Endpoint::builder()
5061                .url("https://s3.cn-north-1.amazonaws.com.cn/99a_b")
5062                .property(
5063                    "authSchemes",
5064                    vec![{
5065                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5066                        out.insert("name".to_string(), "sigv4".to_string().into());
5067                        out.insert("signingName".to_string(), "s3".to_string().into());
5068                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5069                        out.insert("disableDoubleEncoding".to_string(), true.into());
5070                        out
5071                    }
5072                    .into()]
5073                )
5074                .build()
5075        );
5076    }
5077
5078    /// vanilla path style@af-south-1
5079    #[test]
5080    fn test_178() {
5081        let params = crate::config::endpoint::Params::builder()
5082            .accelerate(false)
5083            .bucket("bucket-name".to_string())
5084            .force_path_style(true)
5085            .region("af-south-1".to_string())
5086            .use_dual_stack(false)
5087            .use_fips(false)
5088            .build()
5089            .expect("invalid params");
5090        let resolver = crate::config::endpoint::DefaultResolver::new();
5091        let endpoint = resolver.resolve_endpoint(&params);
5092        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/bucket-name");
5093        assert_eq!(
5094            endpoint,
5095            ::aws_smithy_types::endpoint::Endpoint::builder()
5096                .url("https://s3.af-south-1.amazonaws.com/bucket-name")
5097                .property(
5098                    "authSchemes",
5099                    vec![{
5100                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5101                        out.insert("name".to_string(), "sigv4".to_string().into());
5102                        out.insert("signingName".to_string(), "s3".to_string().into());
5103                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5104                        out.insert("disableDoubleEncoding".to_string(), true.into());
5105                        out
5106                    }
5107                    .into()]
5108                )
5109                .build()
5110        );
5111    }
5112
5113    /// path style + fips@af-south-1
5114    #[test]
5115    fn test_179() {
5116        let params = crate::config::endpoint::Params::builder()
5117            .accelerate(false)
5118            .bucket("bucket-name".to_string())
5119            .force_path_style(true)
5120            .region("af-south-1".to_string())
5121            .use_dual_stack(false)
5122            .use_fips(true)
5123            .build()
5124            .expect("invalid params");
5125        let resolver = crate::config::endpoint::DefaultResolver::new();
5126        let endpoint = resolver.resolve_endpoint(&params);
5127        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.af-south-1.amazonaws.com/bucket-name");
5128        assert_eq!(
5129            endpoint,
5130            ::aws_smithy_types::endpoint::Endpoint::builder()
5131                .url("https://s3-fips.af-south-1.amazonaws.com/bucket-name")
5132                .property(
5133                    "authSchemes",
5134                    vec![{
5135                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5136                        out.insert("signingName".to_string(), "s3".to_string().into());
5137                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5138                        out.insert("disableDoubleEncoding".to_string(), true.into());
5139                        out.insert("name".to_string(), "sigv4".to_string().into());
5140                        out
5141                    }
5142                    .into()]
5143                )
5144                .build()
5145        );
5146    }
5147
5148    /// path style + accelerate = error@af-south-1
5149    #[test]
5150    fn test_180() {
5151        let params = crate::config::endpoint::Params::builder()
5152            .accelerate(true)
5153            .bucket("bucket-name".to_string())
5154            .force_path_style(true)
5155            .region("af-south-1".to_string())
5156            .use_dual_stack(false)
5157            .use_fips(false)
5158            .build()
5159            .expect("invalid params");
5160        let resolver = crate::config::endpoint::DefaultResolver::new();
5161        let endpoint = resolver.resolve_endpoint(&params);
5162        let error = endpoint
5163            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@af-south-1]");
5164        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
5165    }
5166
5167    /// path style + dualstack@af-south-1
5168    #[test]
5169    fn test_181() {
5170        let params = crate::config::endpoint::Params::builder()
5171            .accelerate(false)
5172            .bucket("bucket-name".to_string())
5173            .force_path_style(true)
5174            .region("af-south-1".to_string())
5175            .use_dual_stack(true)
5176            .use_fips(false)
5177            .build()
5178            .expect("invalid params");
5179        let resolver = crate::config::endpoint::DefaultResolver::new();
5180        let endpoint = resolver.resolve_endpoint(&params);
5181        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.af-south-1.amazonaws.com/bucket-name");
5182        assert_eq!(
5183            endpoint,
5184            ::aws_smithy_types::endpoint::Endpoint::builder()
5185                .url("https://s3.dualstack.af-south-1.amazonaws.com/bucket-name")
5186                .property(
5187                    "authSchemes",
5188                    vec![{
5189                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5190                        out.insert("name".to_string(), "sigv4".to_string().into());
5191                        out.insert("signingName".to_string(), "s3".to_string().into());
5192                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5193                        out.insert("disableDoubleEncoding".to_string(), true.into());
5194                        out
5195                    }
5196                    .into()]
5197                )
5198                .build()
5199        );
5200    }
5201
5202    /// path style + arn is error@af-south-1
5203    #[test]
5204    fn test_182() {
5205        let params = crate::config::endpoint::Params::builder()
5206            .accelerate(false)
5207            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
5208            .force_path_style(true)
5209            .region("af-south-1".to_string())
5210            .use_dual_stack(false)
5211            .use_fips(false)
5212            .build()
5213            .expect("invalid params");
5214        let resolver = crate::config::endpoint::DefaultResolver::new();
5215        let endpoint = resolver.resolve_endpoint(&params);
5216        let error =
5217            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@af-south-1]");
5218        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
5219    }
5220
5221    /// path style + invalid DNS name@af-south-1
5222    #[test]
5223    fn test_183() {
5224        let params = crate::config::endpoint::Params::builder()
5225            .accelerate(false)
5226            .bucket("99a_b".to_string())
5227            .force_path_style(true)
5228            .region("af-south-1".to_string())
5229            .use_dual_stack(false)
5230            .use_fips(false)
5231            .build()
5232            .expect("invalid params");
5233        let resolver = crate::config::endpoint::DefaultResolver::new();
5234        let endpoint = resolver.resolve_endpoint(&params);
5235        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/99a_b");
5236        assert_eq!(
5237            endpoint,
5238            ::aws_smithy_types::endpoint::Endpoint::builder()
5239                .url("https://s3.af-south-1.amazonaws.com/99a_b")
5240                .property(
5241                    "authSchemes",
5242                    vec![{
5243                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5244                        out.insert("name".to_string(), "sigv4".to_string().into());
5245                        out.insert("signingName".to_string(), "s3".to_string().into());
5246                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5247                        out.insert("disableDoubleEncoding".to_string(), true.into());
5248                        out
5249                    }
5250                    .into()]
5251                )
5252                .build()
5253        );
5254    }
5255
5256    /// no path style + invalid DNS name@af-south-1
5257    #[test]
5258    fn test_184() {
5259        let params = crate::config::endpoint::Params::builder()
5260            .accelerate(false)
5261            .bucket("99a_b".to_string())
5262            .region("af-south-1".to_string())
5263            .use_dual_stack(false)
5264            .use_fips(false)
5265            .build()
5266            .expect("invalid params");
5267        let resolver = crate::config::endpoint::DefaultResolver::new();
5268        let endpoint = resolver.resolve_endpoint(&params);
5269        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/99a_b");
5270        assert_eq!(
5271            endpoint,
5272            ::aws_smithy_types::endpoint::Endpoint::builder()
5273                .url("https://s3.af-south-1.amazonaws.com/99a_b")
5274                .property(
5275                    "authSchemes",
5276                    vec![{
5277                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5278                        out.insert("name".to_string(), "sigv4".to_string().into());
5279                        out.insert("signingName".to_string(), "s3".to_string().into());
5280                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5281                        out.insert("disableDoubleEncoding".to_string(), true.into());
5282                        out
5283                    }
5284                    .into()]
5285                )
5286                .build()
5287        );
5288    }
5289
5290    /// virtual addressing + private link@us-west-2
5291    #[test]
5292    fn test_185() {
5293        let params = crate::config::endpoint::Params::builder()
5294            .accelerate(false)
5295            .bucket("bucket-name".to_string())
5296            .force_path_style(false)
5297            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5298            .region("us-west-2".to_string())
5299            .use_dual_stack(false)
5300            .use_fips(false)
5301            .build()
5302            .expect("invalid params");
5303        let resolver = crate::config::endpoint::DefaultResolver::new();
5304        let endpoint = resolver.resolve_endpoint(&params);
5305        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
5306        assert_eq!(
5307            endpoint,
5308            ::aws_smithy_types::endpoint::Endpoint::builder()
5309                .url("http://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
5310                .property(
5311                    "authSchemes",
5312                    vec![{
5313                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5314                        out.insert("name".to_string(), "sigv4".to_string().into());
5315                        out.insert("signingName".to_string(), "s3".to_string().into());
5316                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5317                        out.insert("disableDoubleEncoding".to_string(), true.into());
5318                        out
5319                    }
5320                    .into()]
5321                )
5322                .build()
5323        );
5324    }
5325
5326    /// path style + private link@us-west-2
5327    #[test]
5328    fn test_186() {
5329        let params = crate::config::endpoint::Params::builder()
5330            .accelerate(false)
5331            .bucket("bucket-name".to_string())
5332            .force_path_style(true)
5333            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5334            .region("us-west-2".to_string())
5335            .use_dual_stack(false)
5336            .use_fips(false)
5337            .build()
5338            .expect("invalid params");
5339        let resolver = crate::config::endpoint::DefaultResolver::new();
5340        let endpoint = resolver.resolve_endpoint(&params);
5341        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
5342        assert_eq!(
5343            endpoint,
5344            ::aws_smithy_types::endpoint::Endpoint::builder()
5345                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
5346                .property(
5347                    "authSchemes",
5348                    vec![{
5349                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5350                        out.insert("name".to_string(), "sigv4".to_string().into());
5351                        out.insert("signingName".to_string(), "s3".to_string().into());
5352                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5353                        out.insert("disableDoubleEncoding".to_string(), true.into());
5354                        out
5355                    }
5356                    .into()]
5357                )
5358                .build()
5359        );
5360    }
5361
5362    /// SDK::Host + FIPS@us-west-2
5363    #[test]
5364    fn test_187() {
5365        let params = crate::config::endpoint::Params::builder()
5366            .accelerate(false)
5367            .bucket("bucket-name".to_string())
5368            .force_path_style(false)
5369            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5370            .region("us-west-2".to_string())
5371            .use_dual_stack(false)
5372            .use_fips(true)
5373            .build()
5374            .expect("invalid params");
5375        let resolver = crate::config::endpoint::DefaultResolver::new();
5376        let endpoint = resolver.resolve_endpoint(&params);
5377        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [SDK::Host + FIPS@us-west-2]");
5378        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
5379    }
5380
5381    /// SDK::Host + DualStack@us-west-2
5382    #[test]
5383    fn test_188() {
5384        let params = crate::config::endpoint::Params::builder()
5385            .accelerate(false)
5386            .bucket("bucket-name".to_string())
5387            .force_path_style(false)
5388            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5389            .region("us-west-2".to_string())
5390            .use_dual_stack(true)
5391            .use_fips(false)
5392            .build()
5393            .expect("invalid params");
5394        let resolver = crate::config::endpoint::DefaultResolver::new();
5395        let endpoint = resolver.resolve_endpoint(&params);
5396        let error =
5397            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@us-west-2]");
5398        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
5399    }
5400
5401    /// SDK::HOST + accelerate@us-west-2
5402    #[test]
5403    fn test_189() {
5404        let params = crate::config::endpoint::Params::builder()
5405            .accelerate(true)
5406            .bucket("bucket-name".to_string())
5407            .force_path_style(false)
5408            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5409            .region("us-west-2".to_string())
5410            .use_dual_stack(false)
5411            .use_fips(false)
5412            .build()
5413            .expect("invalid params");
5414        let resolver = crate::config::endpoint::DefaultResolver::new();
5415        let endpoint = resolver.resolve_endpoint(&params);
5416        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@us-west-2]");
5417        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
5418    }
5419
5420    /// SDK::Host + access point ARN@us-west-2
5421    #[test]
5422    fn test_190() {
5423        let params = crate::config::endpoint::Params::builder()
5424            .accelerate(false)
5425            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5426            .force_path_style(false)
5427            .endpoint("https://beta.example.com".to_string())
5428            .region("us-west-2".to_string())
5429            .use_dual_stack(false)
5430            .use_fips(false)
5431            .build()
5432            .expect("invalid params");
5433        let resolver = crate::config::endpoint::DefaultResolver::new();
5434        let endpoint = resolver.resolve_endpoint(&params);
5435        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
5436        assert_eq!(
5437            endpoint,
5438            ::aws_smithy_types::endpoint::Endpoint::builder()
5439                .url("https://myendpoint-123456789012.beta.example.com")
5440                .property(
5441                    "authSchemes",
5442                    vec![{
5443                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5444                        out.insert("name".to_string(), "sigv4".to_string().into());
5445                        out.insert("signingName".to_string(), "s3".to_string().into());
5446                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5447                        out.insert("disableDoubleEncoding".to_string(), true.into());
5448                        out
5449                    }
5450                    .into()]
5451                )
5452                .build()
5453        );
5454    }
5455
5456    /// virtual addressing + private link@cn-north-1
5457    #[test]
5458    fn test_191() {
5459        let params = crate::config::endpoint::Params::builder()
5460            .accelerate(false)
5461            .bucket("bucket-name".to_string())
5462            .force_path_style(false)
5463            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5464            .region("cn-north-1".to_string())
5465            .use_dual_stack(false)
5466            .use_fips(false)
5467            .build()
5468            .expect("invalid params");
5469        let resolver = crate::config::endpoint::DefaultResolver::new();
5470        let endpoint = resolver.resolve_endpoint(&params);
5471        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
5472        assert_eq!(
5473            endpoint,
5474            ::aws_smithy_types::endpoint::Endpoint::builder()
5475                .url("https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
5476                .property(
5477                    "authSchemes",
5478                    vec![{
5479                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5480                        out.insert("name".to_string(), "sigv4".to_string().into());
5481                        out.insert("signingName".to_string(), "s3".to_string().into());
5482                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5483                        out.insert("disableDoubleEncoding".to_string(), true.into());
5484                        out
5485                    }
5486                    .into()]
5487                )
5488                .build()
5489        );
5490    }
5491
5492    /// path style + private link@cn-north-1
5493    #[test]
5494    fn test_192() {
5495        let params = crate::config::endpoint::Params::builder()
5496            .accelerate(false)
5497            .bucket("bucket-name".to_string())
5498            .force_path_style(true)
5499            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5500            .region("cn-north-1".to_string())
5501            .use_dual_stack(false)
5502            .use_fips(false)
5503            .build()
5504            .expect("invalid params");
5505        let resolver = crate::config::endpoint::DefaultResolver::new();
5506        let endpoint = resolver.resolve_endpoint(&params);
5507        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
5508        assert_eq!(
5509            endpoint,
5510            ::aws_smithy_types::endpoint::Endpoint::builder()
5511                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
5512                .property(
5513                    "authSchemes",
5514                    vec![{
5515                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5516                        out.insert("name".to_string(), "sigv4".to_string().into());
5517                        out.insert("signingName".to_string(), "s3".to_string().into());
5518                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5519                        out.insert("disableDoubleEncoding".to_string(), true.into());
5520                        out
5521                    }
5522                    .into()]
5523                )
5524                .build()
5525        );
5526    }
5527
5528    /// FIPS@cn-north-1
5529    #[test]
5530    fn test_193() {
5531        let params = crate::config::endpoint::Params::builder()
5532            .accelerate(false)
5533            .bucket("bucket-name".to_string())
5534            .force_path_style(false)
5535            .region("cn-north-1".to_string())
5536            .use_dual_stack(false)
5537            .use_fips(true)
5538            .build()
5539            .expect("invalid params");
5540        let resolver = crate::config::endpoint::DefaultResolver::new();
5541        let endpoint = resolver.resolve_endpoint(&params);
5542        let error = endpoint.expect_err("expected error: Partition does not support FIPS [FIPS@cn-north-1]");
5543        assert_eq!(format!("{}", error), "Partition does not support FIPS")
5544    }
5545
5546    /// SDK::Host + DualStack@cn-north-1
5547    #[test]
5548    fn test_194() {
5549        let params = crate::config::endpoint::Params::builder()
5550            .accelerate(false)
5551            .bucket("bucket-name".to_string())
5552            .force_path_style(false)
5553            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5554            .region("cn-north-1".to_string())
5555            .use_dual_stack(true)
5556            .use_fips(false)
5557            .build()
5558            .expect("invalid params");
5559        let resolver = crate::config::endpoint::DefaultResolver::new();
5560        let endpoint = resolver.resolve_endpoint(&params);
5561        let error =
5562            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@cn-north-1]");
5563        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
5564    }
5565
5566    /// SDK::HOST + accelerate@cn-north-1
5567    #[test]
5568    fn test_195() {
5569        let params = crate::config::endpoint::Params::builder()
5570            .accelerate(true)
5571            .bucket("bucket-name".to_string())
5572            .force_path_style(false)
5573            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5574            .region("cn-north-1".to_string())
5575            .use_dual_stack(false)
5576            .use_fips(false)
5577            .build()
5578            .expect("invalid params");
5579        let resolver = crate::config::endpoint::DefaultResolver::new();
5580        let endpoint = resolver.resolve_endpoint(&params);
5581        let error =
5582            endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@cn-north-1]");
5583        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
5584    }
5585
5586    /// SDK::Host + access point ARN@cn-north-1
5587    #[test]
5588    fn test_196() {
5589        let params = crate::config::endpoint::Params::builder()
5590            .accelerate(false)
5591            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5592            .force_path_style(false)
5593            .endpoint("https://beta.example.com".to_string())
5594            .region("cn-north-1".to_string())
5595            .use_dual_stack(false)
5596            .use_fips(false)
5597            .build()
5598            .expect("invalid params");
5599        let resolver = crate::config::endpoint::DefaultResolver::new();
5600        let endpoint = resolver.resolve_endpoint(&params);
5601        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
5602        assert_eq!(
5603            endpoint,
5604            ::aws_smithy_types::endpoint::Endpoint::builder()
5605                .url("https://myendpoint-123456789012.beta.example.com")
5606                .property(
5607                    "authSchemes",
5608                    vec![{
5609                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5610                        out.insert("name".to_string(), "sigv4".to_string().into());
5611                        out.insert("signingName".to_string(), "s3".to_string().into());
5612                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5613                        out.insert("disableDoubleEncoding".to_string(), true.into());
5614                        out
5615                    }
5616                    .into()]
5617                )
5618                .build()
5619        );
5620    }
5621
5622    /// virtual addressing + private link@af-south-1
5623    #[test]
5624    fn test_197() {
5625        let params = crate::config::endpoint::Params::builder()
5626            .accelerate(false)
5627            .bucket("bucket-name".to_string())
5628            .force_path_style(false)
5629            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5630            .region("af-south-1".to_string())
5631            .use_dual_stack(false)
5632            .use_fips(false)
5633            .build()
5634            .expect("invalid params");
5635        let resolver = crate::config::endpoint::DefaultResolver::new();
5636        let endpoint = resolver.resolve_endpoint(&params);
5637        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
5638        assert_eq!(
5639            endpoint,
5640            ::aws_smithy_types::endpoint::Endpoint::builder()
5641                .url("https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
5642                .property(
5643                    "authSchemes",
5644                    vec![{
5645                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5646                        out.insert("name".to_string(), "sigv4".to_string().into());
5647                        out.insert("signingName".to_string(), "s3".to_string().into());
5648                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5649                        out.insert("disableDoubleEncoding".to_string(), true.into());
5650                        out
5651                    }
5652                    .into()]
5653                )
5654                .build()
5655        );
5656    }
5657
5658    /// path style + private link@af-south-1
5659    #[test]
5660    fn test_198() {
5661        let params = crate::config::endpoint::Params::builder()
5662            .accelerate(false)
5663            .bucket("bucket-name".to_string())
5664            .force_path_style(true)
5665            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5666            .region("af-south-1".to_string())
5667            .use_dual_stack(false)
5668            .use_fips(false)
5669            .build()
5670            .expect("invalid params");
5671        let resolver = crate::config::endpoint::DefaultResolver::new();
5672        let endpoint = resolver.resolve_endpoint(&params);
5673        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
5674        assert_eq!(
5675            endpoint,
5676            ::aws_smithy_types::endpoint::Endpoint::builder()
5677                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
5678                .property(
5679                    "authSchemes",
5680                    vec![{
5681                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5682                        out.insert("name".to_string(), "sigv4".to_string().into());
5683                        out.insert("signingName".to_string(), "s3".to_string().into());
5684                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5685                        out.insert("disableDoubleEncoding".to_string(), true.into());
5686                        out
5687                    }
5688                    .into()]
5689                )
5690                .build()
5691        );
5692    }
5693
5694    /// SDK::Host + FIPS@af-south-1
5695    #[test]
5696    fn test_199() {
5697        let params = crate::config::endpoint::Params::builder()
5698            .accelerate(false)
5699            .bucket("bucket-name".to_string())
5700            .force_path_style(false)
5701            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5702            .region("af-south-1".to_string())
5703            .use_dual_stack(false)
5704            .use_fips(true)
5705            .build()
5706            .expect("invalid params");
5707        let resolver = crate::config::endpoint::DefaultResolver::new();
5708        let endpoint = resolver.resolve_endpoint(&params);
5709        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [SDK::Host + FIPS@af-south-1]");
5710        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
5711    }
5712
5713    /// SDK::Host + DualStack@af-south-1
5714    #[test]
5715    fn test_200() {
5716        let params = crate::config::endpoint::Params::builder()
5717            .accelerate(false)
5718            .bucket("bucket-name".to_string())
5719            .force_path_style(false)
5720            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5721            .region("af-south-1".to_string())
5722            .use_dual_stack(true)
5723            .use_fips(false)
5724            .build()
5725            .expect("invalid params");
5726        let resolver = crate::config::endpoint::DefaultResolver::new();
5727        let endpoint = resolver.resolve_endpoint(&params);
5728        let error =
5729            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@af-south-1]");
5730        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
5731    }
5732
5733    /// SDK::HOST + accelerate@af-south-1
5734    #[test]
5735    fn test_201() {
5736        let params = crate::config::endpoint::Params::builder()
5737            .accelerate(true)
5738            .bucket("bucket-name".to_string())
5739            .force_path_style(false)
5740            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5741            .region("af-south-1".to_string())
5742            .use_dual_stack(false)
5743            .use_fips(false)
5744            .build()
5745            .expect("invalid params");
5746        let resolver = crate::config::endpoint::DefaultResolver::new();
5747        let endpoint = resolver.resolve_endpoint(&params);
5748        let error =
5749            endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@af-south-1]");
5750        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
5751    }
5752
5753    /// SDK::Host + access point ARN@af-south-1
5754    #[test]
5755    fn test_202() {
5756        let params = crate::config::endpoint::Params::builder()
5757            .accelerate(false)
5758            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5759            .force_path_style(false)
5760            .endpoint("https://beta.example.com".to_string())
5761            .region("af-south-1".to_string())
5762            .use_dual_stack(false)
5763            .use_fips(false)
5764            .build()
5765            .expect("invalid params");
5766        let resolver = crate::config::endpoint::DefaultResolver::new();
5767        let endpoint = resolver.resolve_endpoint(&params);
5768        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
5769        assert_eq!(
5770            endpoint,
5771            ::aws_smithy_types::endpoint::Endpoint::builder()
5772                .url("https://myendpoint-123456789012.beta.example.com")
5773                .property(
5774                    "authSchemes",
5775                    vec![{
5776                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5777                        out.insert("name".to_string(), "sigv4".to_string().into());
5778                        out.insert("signingName".to_string(), "s3".to_string().into());
5779                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5780                        out.insert("disableDoubleEncoding".to_string(), true.into());
5781                        out
5782                    }
5783                    .into()]
5784                )
5785                .build()
5786        );
5787    }
5788
5789    /// vanilla access point arn@us-west-2
5790    #[test]
5791    fn test_203() {
5792        let params = crate::config::endpoint::Params::builder()
5793            .accelerate(false)
5794            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5795            .force_path_style(false)
5796            .region("us-west-2".to_string())
5797            .use_dual_stack(false)
5798            .use_fips(false)
5799            .build()
5800            .expect("invalid params");
5801        let resolver = crate::config::endpoint::DefaultResolver::new();
5802        let endpoint = resolver.resolve_endpoint(&params);
5803        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
5804        assert_eq!(
5805            endpoint,
5806            ::aws_smithy_types::endpoint::Endpoint::builder()
5807                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
5808                .property(
5809                    "authSchemes",
5810                    vec![{
5811                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5812                        out.insert("name".to_string(), "sigv4".to_string().into());
5813                        out.insert("signingName".to_string(), "s3".to_string().into());
5814                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5815                        out.insert("disableDoubleEncoding".to_string(), true.into());
5816                        out
5817                    }
5818                    .into()]
5819                )
5820                .build()
5821        );
5822    }
5823
5824    /// access point arn + FIPS@us-west-2
5825    #[test]
5826    fn test_204() {
5827        let params = crate::config::endpoint::Params::builder()
5828            .accelerate(false)
5829            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5830            .force_path_style(false)
5831            .region("us-west-2".to_string())
5832            .use_dual_stack(false)
5833            .use_fips(true)
5834            .build()
5835            .expect("invalid params");
5836        let resolver = crate::config::endpoint::DefaultResolver::new();
5837        let endpoint = resolver.resolve_endpoint(&params);
5838        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.us-west-2.amazonaws.com");
5839        assert_eq!(
5840            endpoint,
5841            ::aws_smithy_types::endpoint::Endpoint::builder()
5842                .url("https://myendpoint-123456789012.s3-accesspoint-fips.us-west-2.amazonaws.com")
5843                .property(
5844                    "authSchemes",
5845                    vec![{
5846                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5847                        out.insert("name".to_string(), "sigv4".to_string().into());
5848                        out.insert("signingName".to_string(), "s3".to_string().into());
5849                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5850                        out.insert("disableDoubleEncoding".to_string(), true.into());
5851                        out
5852                    }
5853                    .into()]
5854                )
5855                .build()
5856        );
5857    }
5858
5859    /// access point arn + accelerate = error@us-west-2
5860    #[test]
5861    fn test_205() {
5862        let params = crate::config::endpoint::Params::builder()
5863            .accelerate(true)
5864            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5865            .force_path_style(false)
5866            .region("us-west-2".to_string())
5867            .use_dual_stack(false)
5868            .use_fips(false)
5869            .build()
5870            .expect("invalid params");
5871        let resolver = crate::config::endpoint::DefaultResolver::new();
5872        let endpoint = resolver.resolve_endpoint(&params);
5873        let error =
5874            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@us-west-2]");
5875        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
5876    }
5877
5878    /// access point arn + FIPS + DualStack@us-west-2
5879    #[test]
5880    fn test_206() {
5881        let params = crate::config::endpoint::Params::builder()
5882            .accelerate(false)
5883            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5884            .force_path_style(false)
5885            .region("us-west-2".to_string())
5886            .use_dual_stack(true)
5887            .use_fips(true)
5888            .build()
5889            .expect("invalid params");
5890        let resolver = crate::config::endpoint::DefaultResolver::new();
5891        let endpoint = resolver.resolve_endpoint(&params);
5892        let endpoint =
5893            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com");
5894        assert_eq!(
5895            endpoint,
5896            ::aws_smithy_types::endpoint::Endpoint::builder()
5897                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com")
5898                .property(
5899                    "authSchemes",
5900                    vec![{
5901                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5902                        out.insert("name".to_string(), "sigv4".to_string().into());
5903                        out.insert("signingName".to_string(), "s3".to_string().into());
5904                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5905                        out.insert("disableDoubleEncoding".to_string(), true.into());
5906                        out
5907                    }
5908                    .into()]
5909                )
5910                .build()
5911        );
5912    }
5913
5914    /// vanilla access point arn@cn-north-1
5915    #[test]
5916    fn test_207() {
5917        let params = crate::config::endpoint::Params::builder()
5918            .accelerate(false)
5919            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5920            .force_path_style(false)
5921            .region("cn-north-1".to_string())
5922            .use_dual_stack(false)
5923            .use_fips(false)
5924            .build()
5925            .expect("invalid params");
5926        let resolver = crate::config::endpoint::DefaultResolver::new();
5927        let endpoint = resolver.resolve_endpoint(&params);
5928        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.cn-north-1.amazonaws.com.cn");
5929        assert_eq!(
5930            endpoint,
5931            ::aws_smithy_types::endpoint::Endpoint::builder()
5932                .url("https://myendpoint-123456789012.s3-accesspoint.cn-north-1.amazonaws.com.cn")
5933                .property(
5934                    "authSchemes",
5935                    vec![{
5936                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5937                        out.insert("name".to_string(), "sigv4".to_string().into());
5938                        out.insert("signingName".to_string(), "s3".to_string().into());
5939                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5940                        out.insert("disableDoubleEncoding".to_string(), true.into());
5941                        out
5942                    }
5943                    .into()]
5944                )
5945                .build()
5946        );
5947    }
5948
5949    /// access point arn + FIPS@cn-north-1
5950    #[test]
5951    fn test_208() {
5952        let params = crate::config::endpoint::Params::builder()
5953            .accelerate(false)
5954            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5955            .force_path_style(false)
5956            .region("cn-north-1".to_string())
5957            .use_dual_stack(false)
5958            .use_fips(true)
5959            .build()
5960            .expect("invalid params");
5961        let resolver = crate::config::endpoint::DefaultResolver::new();
5962        let endpoint = resolver.resolve_endpoint(&params);
5963        let error = endpoint.expect_err("expected error: Partition does not support FIPS [access point arn + FIPS@cn-north-1]");
5964        assert_eq!(format!("{}", error), "Partition does not support FIPS")
5965    }
5966
5967    /// access point arn + accelerate = error@cn-north-1
5968    #[test]
5969    fn test_209() {
5970        let params = crate::config::endpoint::Params::builder()
5971            .accelerate(true)
5972            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5973            .force_path_style(false)
5974            .region("cn-north-1".to_string())
5975            .use_dual_stack(false)
5976            .use_fips(false)
5977            .build()
5978            .expect("invalid params");
5979        let resolver = crate::config::endpoint::DefaultResolver::new();
5980        let endpoint = resolver.resolve_endpoint(&params);
5981        let error =
5982            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@cn-north-1]");
5983        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
5984    }
5985
5986    /// access point arn + FIPS + DualStack@cn-north-1
5987    #[test]
5988    fn test_210() {
5989        let params = crate::config::endpoint::Params::builder()
5990            .accelerate(false)
5991            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5992            .force_path_style(false)
5993            .region("cn-north-1".to_string())
5994            .use_dual_stack(true)
5995            .use_fips(true)
5996            .build()
5997            .expect("invalid params");
5998        let resolver = crate::config::endpoint::DefaultResolver::new();
5999        let endpoint = resolver.resolve_endpoint(&params);
6000        let error = endpoint.expect_err("expected error: Partition does not support FIPS [access point arn + FIPS + DualStack@cn-north-1]");
6001        assert_eq!(format!("{}", error), "Partition does not support FIPS")
6002    }
6003
6004    /// vanilla access point arn@af-south-1
6005    #[test]
6006    fn test_211() {
6007        let params = crate::config::endpoint::Params::builder()
6008            .accelerate(false)
6009            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
6010            .force_path_style(false)
6011            .region("af-south-1".to_string())
6012            .use_dual_stack(false)
6013            .use_fips(false)
6014            .build()
6015            .expect("invalid params");
6016        let resolver = crate::config::endpoint::DefaultResolver::new();
6017        let endpoint = resolver.resolve_endpoint(&params);
6018        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.af-south-1.amazonaws.com");
6019        assert_eq!(
6020            endpoint,
6021            ::aws_smithy_types::endpoint::Endpoint::builder()
6022                .url("https://myendpoint-123456789012.s3-accesspoint.af-south-1.amazonaws.com")
6023                .property(
6024                    "authSchemes",
6025                    vec![{
6026                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6027                        out.insert("name".to_string(), "sigv4".to_string().into());
6028                        out.insert("signingName".to_string(), "s3".to_string().into());
6029                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
6030                        out.insert("disableDoubleEncoding".to_string(), true.into());
6031                        out
6032                    }
6033                    .into()]
6034                )
6035                .build()
6036        );
6037    }
6038
6039    /// access point arn + FIPS@af-south-1
6040    #[test]
6041    fn test_212() {
6042        let params = crate::config::endpoint::Params::builder()
6043            .accelerate(false)
6044            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
6045            .force_path_style(false)
6046            .region("af-south-1".to_string())
6047            .use_dual_stack(false)
6048            .use_fips(true)
6049            .build()
6050            .expect("invalid params");
6051        let resolver = crate::config::endpoint::DefaultResolver::new();
6052        let endpoint = resolver.resolve_endpoint(&params);
6053        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.af-south-1.amazonaws.com");
6054        assert_eq!(
6055            endpoint,
6056            ::aws_smithy_types::endpoint::Endpoint::builder()
6057                .url("https://myendpoint-123456789012.s3-accesspoint-fips.af-south-1.amazonaws.com")
6058                .property(
6059                    "authSchemes",
6060                    vec![{
6061                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6062                        out.insert("name".to_string(), "sigv4".to_string().into());
6063                        out.insert("signingName".to_string(), "s3".to_string().into());
6064                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
6065                        out.insert("disableDoubleEncoding".to_string(), true.into());
6066                        out
6067                    }
6068                    .into()]
6069                )
6070                .build()
6071        );
6072    }
6073
6074    /// access point arn + accelerate = error@af-south-1
6075    #[test]
6076    fn test_213() {
6077        let params = crate::config::endpoint::Params::builder()
6078            .accelerate(true)
6079            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
6080            .force_path_style(false)
6081            .region("af-south-1".to_string())
6082            .use_dual_stack(false)
6083            .use_fips(false)
6084            .build()
6085            .expect("invalid params");
6086        let resolver = crate::config::endpoint::DefaultResolver::new();
6087        let endpoint = resolver.resolve_endpoint(&params);
6088        let error =
6089            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@af-south-1]");
6090        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
6091    }
6092
6093    /// access point arn + FIPS + DualStack@af-south-1
6094    #[test]
6095    fn test_214() {
6096        let params = crate::config::endpoint::Params::builder()
6097            .accelerate(false)
6098            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
6099            .force_path_style(false)
6100            .region("af-south-1".to_string())
6101            .use_dual_stack(true)
6102            .use_fips(true)
6103            .build()
6104            .expect("invalid params");
6105        let resolver = crate::config::endpoint::DefaultResolver::new();
6106        let endpoint = resolver.resolve_endpoint(&params);
6107        let endpoint =
6108            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.af-south-1.amazonaws.com");
6109        assert_eq!(
6110            endpoint,
6111            ::aws_smithy_types::endpoint::Endpoint::builder()
6112                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.af-south-1.amazonaws.com")
6113                .property(
6114                    "authSchemes",
6115                    vec![{
6116                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6117                        out.insert("name".to_string(), "sigv4".to_string().into());
6118                        out.insert("signingName".to_string(), "s3".to_string().into());
6119                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
6120                        out.insert("disableDoubleEncoding".to_string(), true.into());
6121                        out
6122                    }
6123                    .into()]
6124                )
6125                .build()
6126        );
6127    }
6128
6129    /// S3 outposts vanilla test
6130    #[test]
6131    fn test_215() {
6132        let params = crate::config::endpoint::Params::builder()
6133            .region("us-west-2".to_string())
6134            .use_fips(false)
6135            .use_dual_stack(false)
6136            .accelerate(false)
6137            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6138            .build()
6139            .expect("invalid params");
6140        let resolver = crate::config::endpoint::DefaultResolver::new();
6141        let endpoint = resolver.resolve_endpoint(&params);
6142        let endpoint =
6143            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-west-2.amazonaws.com");
6144        assert_eq!(
6145            endpoint,
6146            ::aws_smithy_types::endpoint::Endpoint::builder()
6147                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-west-2.amazonaws.com")
6148                .property(
6149                    "authSchemes",
6150                    vec![
6151                        {
6152                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6153                            out.insert("name".to_string(), "sigv4a".to_string().into());
6154                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6155                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
6156                            out.insert("disableDoubleEncoding".to_string(), true.into());
6157                            out
6158                        }
6159                        .into(),
6160                        {
6161                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6162                            out.insert("name".to_string(), "sigv4".to_string().into());
6163                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6164                            out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6165                            out.insert("disableDoubleEncoding".to_string(), true.into());
6166                            out
6167                        }
6168                        .into()
6169                    ]
6170                )
6171                .build()
6172        );
6173    }
6174
6175    /// S3 outposts custom endpoint
6176    #[test]
6177    fn test_216() {
6178        let params = crate::config::endpoint::Params::builder()
6179            .region("us-west-2".to_string())
6180            .use_fips(false)
6181            .use_dual_stack(false)
6182            .accelerate(false)
6183            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6184            .endpoint("https://example.amazonaws.com".to_string())
6185            .build()
6186            .expect("invalid params");
6187        let resolver = crate::config::endpoint::DefaultResolver::new();
6188        let endpoint = resolver.resolve_endpoint(&params);
6189        let endpoint = endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.example.amazonaws.com");
6190        assert_eq!(
6191            endpoint,
6192            ::aws_smithy_types::endpoint::Endpoint::builder()
6193                .url("https://reports-123456789012.op-01234567890123456.example.amazonaws.com")
6194                .property(
6195                    "authSchemes",
6196                    vec![
6197                        {
6198                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6199                            out.insert("name".to_string(), "sigv4a".to_string().into());
6200                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6201                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
6202                            out.insert("disableDoubleEncoding".to_string(), true.into());
6203                            out
6204                        }
6205                        .into(),
6206                        {
6207                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6208                            out.insert("name".to_string(), "sigv4".to_string().into());
6209                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6210                            out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6211                            out.insert("disableDoubleEncoding".to_string(), true.into());
6212                            out
6213                        }
6214                        .into()
6215                    ]
6216                )
6217                .build()
6218        );
6219    }
6220
6221    /// outposts arn with region mismatch and UseArnRegion=false
6222    #[test]
6223    fn test_217() {
6224        let params = crate::config::endpoint::Params::builder()
6225            .accelerate(false)
6226            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6227            .force_path_style(false)
6228            .use_arn_region(false)
6229            .region("us-west-2".to_string())
6230            .use_dual_stack(false)
6231            .use_fips(false)
6232            .build()
6233            .expect("invalid params");
6234        let resolver = crate::config::endpoint::DefaultResolver::new();
6235        let endpoint = resolver.resolve_endpoint(&params);
6236        let error = endpoint.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false` [outposts arn with region mismatch and UseArnRegion=false]");
6237        assert_eq!(
6238            format!("{}", error),
6239            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
6240        )
6241    }
6242
6243    /// outposts arn with region mismatch, custom region and UseArnRegion=false
6244    #[test]
6245    fn test_218() {
6246        let params = crate::config::endpoint::Params::builder()
6247            .accelerate(false)
6248            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6249            .endpoint("https://example.com".to_string())
6250            .force_path_style(false)
6251            .use_arn_region(false)
6252            .region("us-west-2".to_string())
6253            .use_dual_stack(false)
6254            .use_fips(false)
6255            .build()
6256            .expect("invalid params");
6257        let resolver = crate::config::endpoint::DefaultResolver::new();
6258        let endpoint = resolver.resolve_endpoint(&params);
6259        let error = endpoint.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false` [outposts arn with region mismatch, custom region and UseArnRegion=false]");
6260        assert_eq!(
6261            format!("{}", error),
6262            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
6263        )
6264    }
6265
6266    /// outposts arn with region mismatch and UseArnRegion=true
6267    #[test]
6268    fn test_219() {
6269        let params = crate::config::endpoint::Params::builder()
6270            .accelerate(false)
6271            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6272            .force_path_style(false)
6273            .use_arn_region(true)
6274            .region("us-west-2".to_string())
6275            .use_dual_stack(false)
6276            .use_fips(false)
6277            .build()
6278            .expect("invalid params");
6279        let resolver = crate::config::endpoint::DefaultResolver::new();
6280        let endpoint = resolver.resolve_endpoint(&params);
6281        let endpoint =
6282            endpoint.expect("Expected valid endpoint: https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
6283        assert_eq!(
6284            endpoint,
6285            ::aws_smithy_types::endpoint::Endpoint::builder()
6286                .url("https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
6287                .property(
6288                    "authSchemes",
6289                    vec![
6290                        {
6291                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6292                            out.insert("name".to_string(), "sigv4a".to_string().into());
6293                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6294                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
6295                            out.insert("disableDoubleEncoding".to_string(), true.into());
6296                            out
6297                        }
6298                        .into(),
6299                        {
6300                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6301                            out.insert("name".to_string(), "sigv4".to_string().into());
6302                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6303                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6304                            out.insert("disableDoubleEncoding".to_string(), true.into());
6305                            out
6306                        }
6307                        .into()
6308                    ]
6309                )
6310                .build()
6311        );
6312    }
6313
6314    /// outposts arn with region mismatch and UseArnRegion unset
6315    #[test]
6316    fn test_220() {
6317        let params = crate::config::endpoint::Params::builder()
6318            .accelerate(false)
6319            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6320            .force_path_style(false)
6321            .region("us-west-2".to_string())
6322            .use_dual_stack(false)
6323            .use_fips(false)
6324            .build()
6325            .expect("invalid params");
6326        let resolver = crate::config::endpoint::DefaultResolver::new();
6327        let endpoint = resolver.resolve_endpoint(&params);
6328        let endpoint =
6329            endpoint.expect("Expected valid endpoint: https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
6330        assert_eq!(
6331            endpoint,
6332            ::aws_smithy_types::endpoint::Endpoint::builder()
6333                .url("https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
6334                .property(
6335                    "authSchemes",
6336                    vec![
6337                        {
6338                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6339                            out.insert("name".to_string(), "sigv4a".to_string().into());
6340                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6341                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
6342                            out.insert("disableDoubleEncoding".to_string(), true.into());
6343                            out
6344                        }
6345                        .into(),
6346                        {
6347                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6348                            out.insert("name".to_string(), "sigv4".to_string().into());
6349                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6350                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6351                            out.insert("disableDoubleEncoding".to_string(), true.into());
6352                            out
6353                        }
6354                        .into()
6355                    ]
6356                )
6357                .build()
6358        );
6359    }
6360
6361    /// outposts arn with partition mismatch and UseArnRegion=true
6362    #[test]
6363    fn test_221() {
6364        let params = crate::config::endpoint::Params::builder()
6365            .accelerate(false)
6366            .bucket("arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6367            .force_path_style(false)
6368            .use_arn_region(true)
6369            .region("us-west-2".to_string())
6370            .use_dual_stack(false)
6371            .use_fips(false)
6372            .build()
6373            .expect("invalid params");
6374        let resolver = crate::config::endpoint::DefaultResolver::new();
6375        let endpoint = resolver.resolve_endpoint(&params);
6376        let error = endpoint.expect_err("expected error: Client was configured for partition `aws` but ARN (`arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint`) has `aws-cn` [outposts arn with partition mismatch and UseArnRegion=true]");
6377        assert_eq!(format!("{}", error), "Client was configured for partition `aws` but ARN (`arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint`) has `aws-cn`")
6378    }
6379
6380    /// ARN with UseGlobalEndpoint and use-east-1 region uses the regional endpoint
6381    #[test]
6382    fn test_222() {
6383        let params = crate::config::endpoint::Params::builder()
6384            .region("us-east-1".to_string())
6385            .use_global_endpoint(true)
6386            .use_fips(false)
6387            .use_dual_stack(false)
6388            .accelerate(false)
6389            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6390            .build()
6391            .expect("invalid params");
6392        let resolver = crate::config::endpoint::DefaultResolver::new();
6393        let endpoint = resolver.resolve_endpoint(&params);
6394        let endpoint =
6395            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
6396        assert_eq!(
6397            endpoint,
6398            ::aws_smithy_types::endpoint::Endpoint::builder()
6399                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
6400                .property(
6401                    "authSchemes",
6402                    vec![
6403                        {
6404                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6405                            out.insert("name".to_string(), "sigv4a".to_string().into());
6406                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6407                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
6408                            out.insert("disableDoubleEncoding".to_string(), true.into());
6409                            out
6410                        }
6411                        .into(),
6412                        {
6413                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6414                            out.insert("name".to_string(), "sigv4".to_string().into());
6415                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6416                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6417                            out.insert("disableDoubleEncoding".to_string(), true.into());
6418                            out
6419                        }
6420                        .into()
6421                    ]
6422                )
6423                .build()
6424        );
6425    }
6426
6427    /// S3 outposts does not support dualstack
6428    #[test]
6429    fn test_223() {
6430        let params = crate::config::endpoint::Params::builder()
6431            .region("us-east-1".to_string())
6432            .use_fips(false)
6433            .use_dual_stack(true)
6434            .accelerate(false)
6435            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6436            .build()
6437            .expect("invalid params");
6438        let resolver = crate::config::endpoint::DefaultResolver::new();
6439        let endpoint = resolver.resolve_endpoint(&params);
6440        let error = endpoint.expect_err("expected error: S3 Outposts does not support Dual-stack [S3 outposts does not support dualstack]");
6441        assert_eq!(format!("{}", error), "S3 Outposts does not support Dual-stack")
6442    }
6443
6444    /// S3 outposts does not support fips
6445    #[test]
6446    fn test_224() {
6447        let params = crate::config::endpoint::Params::builder()
6448            .region("us-east-1".to_string())
6449            .use_fips(true)
6450            .use_dual_stack(false)
6451            .accelerate(false)
6452            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6453            .build()
6454            .expect("invalid params");
6455        let resolver = crate::config::endpoint::DefaultResolver::new();
6456        let endpoint = resolver.resolve_endpoint(&params);
6457        let error = endpoint.expect_err("expected error: S3 Outposts does not support FIPS [S3 outposts does not support fips]");
6458        assert_eq!(format!("{}", error), "S3 Outposts does not support FIPS")
6459    }
6460
6461    /// S3 outposts does not support accelerate
6462    #[test]
6463    fn test_225() {
6464        let params = crate::config::endpoint::Params::builder()
6465            .region("us-east-1".to_string())
6466            .use_fips(false)
6467            .use_dual_stack(false)
6468            .accelerate(true)
6469            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6470            .build()
6471            .expect("invalid params");
6472        let resolver = crate::config::endpoint::DefaultResolver::new();
6473        let endpoint = resolver.resolve_endpoint(&params);
6474        let error = endpoint.expect_err("expected error: S3 Outposts does not support S3 Accelerate [S3 outposts does not support accelerate]");
6475        assert_eq!(format!("{}", error), "S3 Outposts does not support S3 Accelerate")
6476    }
6477
6478    /// validates against subresource
6479    #[test]
6480    fn test_226() {
6481        let params = crate::config::endpoint::Params::builder()
6482            .region("us-west-2".to_string())
6483            .use_fips(false)
6484            .use_dual_stack(false)
6485            .accelerate(false)
6486            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:mybucket:object:foo".to_string())
6487            .build()
6488            .expect("invalid params");
6489        let resolver = crate::config::endpoint::DefaultResolver::new();
6490        let endpoint = resolver.resolve_endpoint(&params);
6491        let error =
6492            endpoint.expect_err("expected error: Invalid Arn: Outpost Access Point ARN contains sub resources [validates against subresource]");
6493        assert_eq!(format!("{}", error), "Invalid Arn: Outpost Access Point ARN contains sub resources")
6494    }
6495
6496    /// object lambda @us-east-1
6497    #[test]
6498    fn test_227() {
6499        let params = crate::config::endpoint::Params::builder()
6500            .region("us-east-1".to_string())
6501            .use_fips(false)
6502            .use_dual_stack(false)
6503            .accelerate(false)
6504            .use_arn_region(false)
6505            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6506            .build()
6507            .expect("invalid params");
6508        let resolver = crate::config::endpoint::DefaultResolver::new();
6509        let endpoint = resolver.resolve_endpoint(&params);
6510        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
6511        assert_eq!(
6512            endpoint,
6513            ::aws_smithy_types::endpoint::Endpoint::builder()
6514                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
6515                .property(
6516                    "authSchemes",
6517                    vec![{
6518                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6519                        out.insert("name".to_string(), "sigv4".to_string().into());
6520                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6521                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6522                        out.insert("disableDoubleEncoding".to_string(), true.into());
6523                        out
6524                    }
6525                    .into()]
6526                )
6527                .build()
6528        );
6529    }
6530
6531    /// object lambda @us-west-2
6532    #[test]
6533    fn test_228() {
6534        let params = crate::config::endpoint::Params::builder()
6535            .region("us-west-2".to_string())
6536            .use_fips(false)
6537            .use_dual_stack(false)
6538            .accelerate(false)
6539            .use_arn_region(false)
6540            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
6541            .build()
6542            .expect("invalid params");
6543        let resolver = crate::config::endpoint::DefaultResolver::new();
6544        let endpoint = resolver.resolve_endpoint(&params);
6545        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com");
6546        assert_eq!(
6547            endpoint,
6548            ::aws_smithy_types::endpoint::Endpoint::builder()
6549                .url("https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com")
6550                .property(
6551                    "authSchemes",
6552                    vec![{
6553                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6554                        out.insert("name".to_string(), "sigv4".to_string().into());
6555                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6556                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6557                        out.insert("disableDoubleEncoding".to_string(), true.into());
6558                        out
6559                    }
6560                    .into()]
6561                )
6562                .build()
6563        );
6564    }
6565
6566    /// object lambda, colon resource deliminator @us-west-2
6567    #[test]
6568    fn test_229() {
6569        let params = crate::config::endpoint::Params::builder()
6570            .region("us-west-2".to_string())
6571            .use_fips(false)
6572            .use_dual_stack(false)
6573            .accelerate(false)
6574            .use_arn_region(false)
6575            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:mybanner".to_string())
6576            .build()
6577            .expect("invalid params");
6578        let resolver = crate::config::endpoint::DefaultResolver::new();
6579        let endpoint = resolver.resolve_endpoint(&params);
6580        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com");
6581        assert_eq!(
6582            endpoint,
6583            ::aws_smithy_types::endpoint::Endpoint::builder()
6584                .url("https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com")
6585                .property(
6586                    "authSchemes",
6587                    vec![{
6588                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6589                        out.insert("name".to_string(), "sigv4".to_string().into());
6590                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6591                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6592                        out.insert("disableDoubleEncoding".to_string(), true.into());
6593                        out
6594                    }
6595                    .into()]
6596                )
6597                .build()
6598        );
6599    }
6600
6601    /// object lambda @us-east-1, client region us-west-2, useArnRegion=true
6602    #[test]
6603    fn test_230() {
6604        let params = crate::config::endpoint::Params::builder()
6605            .region("us-west-2".to_string())
6606            .use_fips(false)
6607            .use_dual_stack(false)
6608            .accelerate(false)
6609            .use_arn_region(true)
6610            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6611            .build()
6612            .expect("invalid params");
6613        let resolver = crate::config::endpoint::DefaultResolver::new();
6614        let endpoint = resolver.resolve_endpoint(&params);
6615        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
6616        assert_eq!(
6617            endpoint,
6618            ::aws_smithy_types::endpoint::Endpoint::builder()
6619                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
6620                .property(
6621                    "authSchemes",
6622                    vec![{
6623                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6624                        out.insert("name".to_string(), "sigv4".to_string().into());
6625                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6626                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6627                        out.insert("disableDoubleEncoding".to_string(), true.into());
6628                        out
6629                    }
6630                    .into()]
6631                )
6632                .build()
6633        );
6634    }
6635
6636    /// object lambda @us-east-1, client region s3-external-1, useArnRegion=true
6637    #[test]
6638    fn test_231() {
6639        let params = crate::config::endpoint::Params::builder()
6640            .region("s3-external-1".to_string())
6641            .use_fips(false)
6642            .use_dual_stack(false)
6643            .accelerate(false)
6644            .use_arn_region(true)
6645            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6646            .build()
6647            .expect("invalid params");
6648        let resolver = crate::config::endpoint::DefaultResolver::new();
6649        let endpoint = resolver.resolve_endpoint(&params);
6650        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
6651        assert_eq!(
6652            endpoint,
6653            ::aws_smithy_types::endpoint::Endpoint::builder()
6654                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
6655                .property(
6656                    "authSchemes",
6657                    vec![{
6658                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6659                        out.insert("name".to_string(), "sigv4".to_string().into());
6660                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6661                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6662                        out.insert("disableDoubleEncoding".to_string(), true.into());
6663                        out
6664                    }
6665                    .into()]
6666                )
6667                .build()
6668        );
6669    }
6670
6671    /// object lambda @us-east-1, client region s3-external-1, useArnRegion=false
6672    #[test]
6673    fn test_232() {
6674        let params = crate::config::endpoint::Params::builder()
6675            .region("s3-external-1".to_string())
6676            .use_fips(false)
6677            .use_dual_stack(false)
6678            .accelerate(false)
6679            .use_arn_region(false)
6680            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6681            .build()
6682            .expect("invalid params");
6683        let resolver = crate::config::endpoint::DefaultResolver::new();
6684        let endpoint = resolver.resolve_endpoint(&params);
6685        let error = endpoint.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `s3-external-1` and UseArnRegion is `false` [object lambda @us-east-1, client region s3-external-1, useArnRegion=false]");
6686        assert_eq!(
6687            format!("{}", error),
6688            "Invalid configuration: region from ARN `us-east-1` does not match client region `s3-external-1` and UseArnRegion is `false`"
6689        )
6690    }
6691
6692    /// object lambda @us-east-1, client region aws-global, useArnRegion=true
6693    #[test]
6694    fn test_233() {
6695        let params = crate::config::endpoint::Params::builder()
6696            .region("aws-global".to_string())
6697            .use_fips(false)
6698            .use_dual_stack(false)
6699            .accelerate(false)
6700            .use_arn_region(true)
6701            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6702            .build()
6703            .expect("invalid params");
6704        let resolver = crate::config::endpoint::DefaultResolver::new();
6705        let endpoint = resolver.resolve_endpoint(&params);
6706        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
6707        assert_eq!(
6708            endpoint,
6709            ::aws_smithy_types::endpoint::Endpoint::builder()
6710                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
6711                .property(
6712                    "authSchemes",
6713                    vec![{
6714                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6715                        out.insert("name".to_string(), "sigv4".to_string().into());
6716                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6717                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6718                        out.insert("disableDoubleEncoding".to_string(), true.into());
6719                        out
6720                    }
6721                    .into()]
6722                )
6723                .build()
6724        );
6725    }
6726
6727    /// object lambda @us-east-1, client region aws-global, useArnRegion=false
6728    #[test]
6729    fn test_234() {
6730        let params = crate::config::endpoint::Params::builder()
6731            .region("aws-global".to_string())
6732            .use_fips(false)
6733            .use_dual_stack(false)
6734            .accelerate(false)
6735            .use_arn_region(false)
6736            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6737            .build()
6738            .expect("invalid params");
6739        let resolver = crate::config::endpoint::DefaultResolver::new();
6740        let endpoint = resolver.resolve_endpoint(&params);
6741        let error = endpoint.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `aws-global` and UseArnRegion is `false` [object lambda @us-east-1, client region aws-global, useArnRegion=false]");
6742        assert_eq!(
6743            format!("{}", error),
6744            "Invalid configuration: region from ARN `us-east-1` does not match client region `aws-global` and UseArnRegion is `false`"
6745        )
6746    }
6747
6748    /// object lambda @cn-north-1, client region us-west-2 (cross partition), useArnRegion=true
6749    #[test]
6750    fn test_235() {
6751        let params = crate::config::endpoint::Params::builder()
6752            .region("aws-global".to_string())
6753            .use_fips(false)
6754            .use_dual_stack(false)
6755            .accelerate(false)
6756            .use_arn_region(true)
6757            .bucket("arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner".to_string())
6758            .build()
6759            .expect("invalid params");
6760        let resolver = crate::config::endpoint::DefaultResolver::new();
6761        let endpoint = resolver.resolve_endpoint(&params);
6762        let error = endpoint.expect_err("expected error: Client was configured for partition `aws` but ARN (`arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner`) has `aws-cn` [object lambda @cn-north-1, client region us-west-2 (cross partition), useArnRegion=true]");
6763        assert_eq!(format!("{}", error), "Client was configured for partition `aws` but ARN (`arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner`) has `aws-cn`")
6764    }
6765
6766    /// object lambda with dualstack
6767    #[test]
6768    fn test_236() {
6769        let params = crate::config::endpoint::Params::builder()
6770            .region("us-west-2".to_string())
6771            .use_fips(false)
6772            .use_dual_stack(true)
6773            .accelerate(false)
6774            .use_arn_region(false)
6775            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
6776            .build()
6777            .expect("invalid params");
6778        let resolver = crate::config::endpoint::DefaultResolver::new();
6779        let endpoint = resolver.resolve_endpoint(&params);
6780        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support Dual-stack [object lambda with dualstack]");
6781        assert_eq!(format!("{}", error), "S3 Object Lambda does not support Dual-stack")
6782    }
6783
6784    /// object lambda @us-gov-east-1
6785    #[test]
6786    fn test_237() {
6787        let params = crate::config::endpoint::Params::builder()
6788            .region("us-gov-east-1".to_string())
6789            .use_fips(false)
6790            .use_dual_stack(false)
6791            .accelerate(false)
6792            .use_arn_region(false)
6793            .bucket("arn:aws-us-gov:s3-object-lambda:us-gov-east-1:123456789012:accesspoint/mybanner".to_string())
6794            .build()
6795            .expect("invalid params");
6796        let resolver = crate::config::endpoint::DefaultResolver::new();
6797        let endpoint = resolver.resolve_endpoint(&params);
6798        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-gov-east-1.amazonaws.com");
6799        assert_eq!(
6800            endpoint,
6801            ::aws_smithy_types::endpoint::Endpoint::builder()
6802                .url("https://mybanner-123456789012.s3-object-lambda.us-gov-east-1.amazonaws.com")
6803                .property(
6804                    "authSchemes",
6805                    vec![{
6806                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6807                        out.insert("name".to_string(), "sigv4".to_string().into());
6808                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6809                        out.insert("signingRegion".to_string(), "us-gov-east-1".to_string().into());
6810                        out.insert("disableDoubleEncoding".to_string(), true.into());
6811                        out
6812                    }
6813                    .into()]
6814                )
6815                .build()
6816        );
6817    }
6818
6819    /// object lambda @us-gov-east-1, with fips
6820    #[test]
6821    fn test_238() {
6822        let params = crate::config::endpoint::Params::builder()
6823            .region("us-gov-east-1".to_string())
6824            .use_fips(true)
6825            .use_dual_stack(false)
6826            .accelerate(false)
6827            .use_arn_region(false)
6828            .bucket("arn:aws-us-gov:s3-object-lambda:us-gov-east-1:123456789012:accesspoint/mybanner".to_string())
6829            .build()
6830            .expect("invalid params");
6831        let resolver = crate::config::endpoint::DefaultResolver::new();
6832        let endpoint = resolver.resolve_endpoint(&params);
6833        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda-fips.us-gov-east-1.amazonaws.com");
6834        assert_eq!(
6835            endpoint,
6836            ::aws_smithy_types::endpoint::Endpoint::builder()
6837                .url("https://mybanner-123456789012.s3-object-lambda-fips.us-gov-east-1.amazonaws.com")
6838                .property(
6839                    "authSchemes",
6840                    vec![{
6841                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6842                        out.insert("name".to_string(), "sigv4".to_string().into());
6843                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6844                        out.insert("signingRegion".to_string(), "us-gov-east-1".to_string().into());
6845                        out.insert("disableDoubleEncoding".to_string(), true.into());
6846                        out
6847                    }
6848                    .into()]
6849                )
6850                .build()
6851        );
6852    }
6853
6854    /// object lambda @cn-north-1, with fips
6855    #[test]
6856    fn test_239() {
6857        let params = crate::config::endpoint::Params::builder()
6858            .region("cn-north-1".to_string())
6859            .use_fips(true)
6860            .use_dual_stack(false)
6861            .accelerate(false)
6862            .use_arn_region(false)
6863            .bucket("arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner".to_string())
6864            .build()
6865            .expect("invalid params");
6866        let resolver = crate::config::endpoint::DefaultResolver::new();
6867        let endpoint = resolver.resolve_endpoint(&params);
6868        let error = endpoint.expect_err("expected error: Partition does not support FIPS [object lambda @cn-north-1, with fips]");
6869        assert_eq!(format!("{}", error), "Partition does not support FIPS")
6870    }
6871
6872    /// object lambda with accelerate
6873    #[test]
6874    fn test_240() {
6875        let params = crate::config::endpoint::Params::builder()
6876            .region("us-west-2".to_string())
6877            .use_fips(false)
6878            .use_dual_stack(false)
6879            .accelerate(true)
6880            .use_arn_region(false)
6881            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
6882            .build()
6883            .expect("invalid params");
6884        let resolver = crate::config::endpoint::DefaultResolver::new();
6885        let endpoint = resolver.resolve_endpoint(&params);
6886        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support S3 Accelerate [object lambda with accelerate]");
6887        assert_eq!(format!("{}", error), "S3 Object Lambda does not support S3 Accelerate")
6888    }
6889
6890    /// object lambda with invalid arn - bad service and someresource
6891    #[test]
6892    fn test_241() {
6893        let params = crate::config::endpoint::Params::builder()
6894            .region("us-west-2".to_string())
6895            .use_fips(false)
6896            .use_dual_stack(false)
6897            .accelerate(false)
6898            .use_arn_region(false)
6899            .bucket("arn:aws:sqs:us-west-2:123456789012:someresource".to_string())
6900            .build()
6901            .expect("invalid params");
6902        let resolver = crate::config::endpoint::DefaultResolver::new();
6903        let endpoint = resolver.resolve_endpoint(&params);
6904        let error = endpoint.expect_err("expected error: Invalid ARN: Unrecognized format: arn:aws:sqs:us-west-2:123456789012:someresource (type: someresource) [object lambda with invalid arn - bad service and someresource]");
6905        assert_eq!(
6906            format!("{}", error),
6907            "Invalid ARN: Unrecognized format: arn:aws:sqs:us-west-2:123456789012:someresource (type: someresource)"
6908        )
6909    }
6910
6911    /// object lambda with invalid arn - invalid resource
6912    #[test]
6913    fn test_242() {
6914        let params = crate::config::endpoint::Params::builder()
6915            .region("us-west-2".to_string())
6916            .use_fips(false)
6917            .use_dual_stack(false)
6918            .accelerate(false)
6919            .use_arn_region(false)
6920            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:bucket_name:mybucket".to_string())
6921            .build()
6922            .expect("invalid params");
6923        let resolver = crate::config::endpoint::DefaultResolver::new();
6924        let endpoint = resolver.resolve_endpoint(&params);
6925        let error = endpoint.expect_err("expected error: Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `bucket_name` [object lambda with invalid arn - invalid resource]");
6926        assert_eq!(
6927            format!("{}", error),
6928            "Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `bucket_name`"
6929        )
6930    }
6931
6932    /// object lambda with invalid arn - missing region
6933    #[test]
6934    fn test_243() {
6935        let params = crate::config::endpoint::Params::builder()
6936            .region("us-west-2".to_string())
6937            .use_fips(false)
6938            .use_dual_stack(false)
6939            .accelerate(false)
6940            .use_arn_region(false)
6941            .bucket("arn:aws:s3-object-lambda::123456789012:accesspoint/mybanner".to_string())
6942            .build()
6943            .expect("invalid params");
6944        let resolver = crate::config::endpoint::DefaultResolver::new();
6945        let endpoint = resolver.resolve_endpoint(&params);
6946        let error =
6947            endpoint.expect_err("expected error: Invalid ARN: bucket ARN is missing a region [object lambda with invalid arn - missing region]");
6948        assert_eq!(format!("{}", error), "Invalid ARN: bucket ARN is missing a region")
6949    }
6950
6951    /// object lambda with invalid arn - missing account-id
6952    #[test]
6953    fn test_244() {
6954        let params = crate::config::endpoint::Params::builder()
6955            .region("us-west-2".to_string())
6956            .use_fips(false)
6957            .use_dual_stack(false)
6958            .accelerate(false)
6959            .use_arn_region(true)
6960            .bucket("arn:aws:s3-object-lambda:us-west-2::accesspoint/mybanner".to_string())
6961            .build()
6962            .expect("invalid params");
6963        let resolver = crate::config::endpoint::DefaultResolver::new();
6964        let endpoint = resolver.resolve_endpoint(&params);
6965        let error = endpoint.expect_err("expected error: Invalid ARN: Missing account id [object lambda with invalid arn - missing account-id]");
6966        assert_eq!(format!("{}", error), "Invalid ARN: Missing account id")
6967    }
6968
6969    /// object lambda with invalid arn - account id contains invalid characters
6970    #[test]
6971    fn test_245() {
6972        let params = crate::config::endpoint::Params::builder()
6973            .region("us-west-2".to_string())
6974            .use_fips(false)
6975            .use_dual_stack(false)
6976            .accelerate(false)
6977            .use_arn_region(true)
6978            .bucket("arn:aws:s3-object-lambda:us-west-2:123.45678.9012:accesspoint:mybucket".to_string())
6979            .build()
6980            .expect("invalid params");
6981        let resolver = crate::config::endpoint::DefaultResolver::new();
6982        let endpoint = resolver.resolve_endpoint(&params);
6983        let error = endpoint.expect_err("expected error: Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123.45678.9012` [object lambda with invalid arn - account id contains invalid characters]");
6984        assert_eq!(
6985            format!("{}", error),
6986            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123.45678.9012`"
6987        )
6988    }
6989
6990    /// object lambda with invalid arn - missing access point name
6991    #[test]
6992    fn test_246() {
6993        let params = crate::config::endpoint::Params::builder()
6994            .region("us-west-2".to_string())
6995            .use_fips(false)
6996            .use_dual_stack(false)
6997            .accelerate(false)
6998            .use_arn_region(true)
6999            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint".to_string())
7000            .build()
7001            .expect("invalid params");
7002        let resolver = crate::config::endpoint::DefaultResolver::new();
7003        let endpoint = resolver.resolve_endpoint(&params);
7004        let error = endpoint.expect_err("expected error: Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided [object lambda with invalid arn - missing access point name]");
7005        assert_eq!(
7006            format!("{}", error),
7007            "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided"
7008        )
7009    }
7010
7011    /// object lambda with invalid arn - access point name contains invalid character: *
7012    #[test]
7013    fn test_247() {
7014        let params = crate::config::endpoint::Params::builder()
7015            .region("us-west-2".to_string())
7016            .use_fips(false)
7017            .use_dual_stack(false)
7018            .accelerate(false)
7019            .use_arn_region(true)
7020            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:*".to_string())
7021            .build()
7022            .expect("invalid params");
7023        let resolver = crate::config::endpoint::DefaultResolver::new();
7024        let endpoint = resolver.resolve_endpoint(&params);
7025        let error = endpoint.expect_err("expected error: Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `*` [object lambda with invalid arn - access point name contains invalid character: *]");
7026        assert_eq!(
7027            format!("{}", error),
7028            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `*`"
7029        )
7030    }
7031
7032    /// object lambda with invalid arn - access point name contains invalid character: .
7033    #[test]
7034    fn test_248() {
7035        let params = crate::config::endpoint::Params::builder()
7036            .region("us-west-2".to_string())
7037            .use_fips(false)
7038            .use_dual_stack(false)
7039            .accelerate(false)
7040            .use_arn_region(true)
7041            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:my.bucket".to_string())
7042            .build()
7043            .expect("invalid params");
7044        let resolver = crate::config::endpoint::DefaultResolver::new();
7045        let endpoint = resolver.resolve_endpoint(&params);
7046        let error = endpoint.expect_err("expected error: Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `my.bucket` [object lambda with invalid arn - access point name contains invalid character: .]");
7047        assert_eq!(
7048            format!("{}", error),
7049            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `my.bucket`"
7050        )
7051    }
7052
7053    /// object lambda with invalid arn - access point name contains sub resources
7054    #[test]
7055    fn test_249() {
7056        let params = crate::config::endpoint::Params::builder()
7057            .region("us-west-2".to_string())
7058            .use_fips(false)
7059            .use_dual_stack(false)
7060            .accelerate(false)
7061            .use_arn_region(true)
7062            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:mybucket:object:foo".to_string())
7063            .build()
7064            .expect("invalid params");
7065        let resolver = crate::config::endpoint::DefaultResolver::new();
7066        let endpoint = resolver.resolve_endpoint(&params);
7067        let error = endpoint.expect_err("expected error: Invalid ARN: The ARN may only contain a single resource component after `accesspoint`. [object lambda with invalid arn - access point name contains sub resources]");
7068        assert_eq!(
7069            format!("{}", error),
7070            "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`."
7071        )
7072    }
7073
7074    /// object lambda with custom endpoint
7075    #[test]
7076    fn test_250() {
7077        let params = crate::config::endpoint::Params::builder()
7078            .region("us-west-2".to_string())
7079            .use_fips(false)
7080            .use_dual_stack(false)
7081            .accelerate(false)
7082            .use_arn_region(false)
7083            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
7084            .endpoint("https://my-endpoint.com".to_string())
7085            .build()
7086            .expect("invalid params");
7087        let resolver = crate::config::endpoint::DefaultResolver::new();
7088        let endpoint = resolver.resolve_endpoint(&params);
7089        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.my-endpoint.com");
7090        assert_eq!(
7091            endpoint,
7092            ::aws_smithy_types::endpoint::Endpoint::builder()
7093                .url("https://mybanner-123456789012.my-endpoint.com")
7094                .property(
7095                    "authSchemes",
7096                    vec![{
7097                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7098                        out.insert("name".to_string(), "sigv4".to_string().into());
7099                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7100                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7101                        out.insert("disableDoubleEncoding".to_string(), true.into());
7102                        out
7103                    }
7104                    .into()]
7105                )
7106                .build()
7107        );
7108    }
7109
7110    /// object lambda arn with region mismatch and UseArnRegion=false
7111    #[test]
7112    fn test_251() {
7113        let params = crate::config::endpoint::Params::builder()
7114            .accelerate(false)
7115            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
7116            .force_path_style(false)
7117            .use_arn_region(false)
7118            .region("us-west-2".to_string())
7119            .use_dual_stack(false)
7120            .use_fips(false)
7121            .build()
7122            .expect("invalid params");
7123        let resolver = crate::config::endpoint::DefaultResolver::new();
7124        let endpoint = resolver.resolve_endpoint(&params);
7125        let error = endpoint.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false` [object lambda arn with region mismatch and UseArnRegion=false]");
7126        assert_eq!(
7127            format!("{}", error),
7128            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
7129        )
7130    }
7131
7132    /// WriteGetObjectResponse @ us-west-2
7133    #[test]
7134    fn test_252() {
7135        let params = crate::config::endpoint::Params::builder()
7136            .accelerate(false)
7137            .use_object_lambda_endpoint(true)
7138            .region("us-west-2".to_string())
7139            .use_dual_stack(false)
7140            .use_fips(false)
7141            .build()
7142            .expect("invalid params");
7143        let resolver = crate::config::endpoint::DefaultResolver::new();
7144        let endpoint = resolver.resolve_endpoint(&params);
7145        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-west-2.amazonaws.com");
7146        assert_eq!(
7147            endpoint,
7148            ::aws_smithy_types::endpoint::Endpoint::builder()
7149                .url("https://s3-object-lambda.us-west-2.amazonaws.com")
7150                .property(
7151                    "authSchemes",
7152                    vec![{
7153                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7154                        out.insert("name".to_string(), "sigv4".to_string().into());
7155                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7156                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7157                        out.insert("disableDoubleEncoding".to_string(), true.into());
7158                        out
7159                    }
7160                    .into()]
7161                )
7162                .build()
7163        );
7164    }
7165
7166    /// WriteGetObjectResponse with custom endpoint
7167    #[test]
7168    fn test_253() {
7169        let params = crate::config::endpoint::Params::builder()
7170            .accelerate(false)
7171            .use_object_lambda_endpoint(true)
7172            .endpoint("https://my-endpoint.com".to_string())
7173            .region("us-west-2".to_string())
7174            .use_dual_stack(false)
7175            .use_fips(false)
7176            .build()
7177            .expect("invalid params");
7178        let resolver = crate::config::endpoint::DefaultResolver::new();
7179        let endpoint = resolver.resolve_endpoint(&params);
7180        let endpoint = endpoint.expect("Expected valid endpoint: https://my-endpoint.com");
7181        assert_eq!(
7182            endpoint,
7183            ::aws_smithy_types::endpoint::Endpoint::builder()
7184                .url("https://my-endpoint.com")
7185                .property(
7186                    "authSchemes",
7187                    vec![{
7188                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7189                        out.insert("name".to_string(), "sigv4".to_string().into());
7190                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7191                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7192                        out.insert("disableDoubleEncoding".to_string(), true.into());
7193                        out
7194                    }
7195                    .into()]
7196                )
7197                .build()
7198        );
7199    }
7200
7201    /// WriteGetObjectResponse @ us-east-1
7202    #[test]
7203    fn test_254() {
7204        let params = crate::config::endpoint::Params::builder()
7205            .accelerate(false)
7206            .use_object_lambda_endpoint(true)
7207            .region("us-east-1".to_string())
7208            .use_dual_stack(false)
7209            .use_fips(false)
7210            .build()
7211            .expect("invalid params");
7212        let resolver = crate::config::endpoint::DefaultResolver::new();
7213        let endpoint = resolver.resolve_endpoint(&params);
7214        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-east-1.amazonaws.com");
7215        assert_eq!(
7216            endpoint,
7217            ::aws_smithy_types::endpoint::Endpoint::builder()
7218                .url("https://s3-object-lambda.us-east-1.amazonaws.com")
7219                .property(
7220                    "authSchemes",
7221                    vec![{
7222                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7223                        out.insert("name".to_string(), "sigv4".to_string().into());
7224                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7225                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7226                        out.insert("disableDoubleEncoding".to_string(), true.into());
7227                        out
7228                    }
7229                    .into()]
7230                )
7231                .build()
7232        );
7233    }
7234
7235    /// WriteGetObjectResponse with fips
7236    #[test]
7237    fn test_255() {
7238        let params = crate::config::endpoint::Params::builder()
7239            .accelerate(false)
7240            .use_object_lambda_endpoint(true)
7241            .region("us-east-1".to_string())
7242            .use_dual_stack(false)
7243            .use_fips(true)
7244            .build()
7245            .expect("invalid params");
7246        let resolver = crate::config::endpoint::DefaultResolver::new();
7247        let endpoint = resolver.resolve_endpoint(&params);
7248        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda-fips.us-east-1.amazonaws.com");
7249        assert_eq!(
7250            endpoint,
7251            ::aws_smithy_types::endpoint::Endpoint::builder()
7252                .url("https://s3-object-lambda-fips.us-east-1.amazonaws.com")
7253                .property(
7254                    "authSchemes",
7255                    vec![{
7256                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7257                        out.insert("name".to_string(), "sigv4".to_string().into());
7258                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7259                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7260                        out.insert("disableDoubleEncoding".to_string(), true.into());
7261                        out
7262                    }
7263                    .into()]
7264                )
7265                .build()
7266        );
7267    }
7268
7269    /// WriteGetObjectResponse with dualstack
7270    #[test]
7271    fn test_256() {
7272        let params = crate::config::endpoint::Params::builder()
7273            .accelerate(false)
7274            .use_object_lambda_endpoint(true)
7275            .region("us-east-1".to_string())
7276            .use_dual_stack(true)
7277            .use_fips(false)
7278            .build()
7279            .expect("invalid params");
7280        let resolver = crate::config::endpoint::DefaultResolver::new();
7281        let endpoint = resolver.resolve_endpoint(&params);
7282        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support Dual-stack [WriteGetObjectResponse with dualstack]");
7283        assert_eq!(format!("{}", error), "S3 Object Lambda does not support Dual-stack")
7284    }
7285
7286    /// WriteGetObjectResponse with accelerate
7287    #[test]
7288    fn test_257() {
7289        let params = crate::config::endpoint::Params::builder()
7290            .accelerate(true)
7291            .use_object_lambda_endpoint(true)
7292            .region("us-east-1".to_string())
7293            .use_dual_stack(false)
7294            .use_fips(false)
7295            .build()
7296            .expect("invalid params");
7297        let resolver = crate::config::endpoint::DefaultResolver::new();
7298        let endpoint = resolver.resolve_endpoint(&params);
7299        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support S3 Accelerate [WriteGetObjectResponse with accelerate]");
7300        assert_eq!(format!("{}", error), "S3 Object Lambda does not support S3 Accelerate")
7301    }
7302
7303    /// WriteGetObjectResponse with fips in CN
7304    #[test]
7305    fn test_258() {
7306        let params = crate::config::endpoint::Params::builder()
7307            .accelerate(false)
7308            .region("cn-north-1".to_string())
7309            .use_object_lambda_endpoint(true)
7310            .use_dual_stack(false)
7311            .use_fips(true)
7312            .build()
7313            .expect("invalid params");
7314        let resolver = crate::config::endpoint::DefaultResolver::new();
7315        let endpoint = resolver.resolve_endpoint(&params);
7316        let error = endpoint.expect_err("expected error: Partition does not support FIPS [WriteGetObjectResponse with fips in CN]");
7317        assert_eq!(format!("{}", error), "Partition does not support FIPS")
7318    }
7319
7320    /// WriteGetObjectResponse with invalid partition
7321    #[test]
7322    fn test_259() {
7323        let params = crate::config::endpoint::Params::builder()
7324            .accelerate(false)
7325            .use_object_lambda_endpoint(true)
7326            .region("not a valid DNS name".to_string())
7327            .use_dual_stack(false)
7328            .use_fips(false)
7329            .build()
7330            .expect("invalid params");
7331        let resolver = crate::config::endpoint::DefaultResolver::new();
7332        let endpoint = resolver.resolve_endpoint(&params);
7333        let error =
7334            endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [WriteGetObjectResponse with invalid partition]");
7335        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
7336    }
7337
7338    /// WriteGetObjectResponse with an unknown partition
7339    #[test]
7340    fn test_260() {
7341        let params = crate::config::endpoint::Params::builder()
7342            .accelerate(false)
7343            .use_object_lambda_endpoint(true)
7344            .region("us-east.special".to_string())
7345            .use_dual_stack(false)
7346            .use_fips(false)
7347            .build()
7348            .expect("invalid params");
7349        let resolver = crate::config::endpoint::DefaultResolver::new();
7350        let endpoint = resolver.resolve_endpoint(&params);
7351        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-east.special.amazonaws.com");
7352        assert_eq!(
7353            endpoint,
7354            ::aws_smithy_types::endpoint::Endpoint::builder()
7355                .url("https://s3-object-lambda.us-east.special.amazonaws.com")
7356                .property(
7357                    "authSchemes",
7358                    vec![{
7359                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7360                        out.insert("name".to_string(), "sigv4".to_string().into());
7361                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7362                        out.insert("disableDoubleEncoding".to_string(), true.into());
7363                        out.insert("signingRegion".to_string(), "us-east.special".to_string().into());
7364                        out
7365                    }
7366                    .into()]
7367                )
7368                .build()
7369        );
7370    }
7371
7372    /// S3 Outposts bucketAlias Real Outpost Prod us-west-1
7373    #[test]
7374    fn test_261() {
7375        let params = crate::config::endpoint::Params::builder()
7376            .region("us-west-1".to_string())
7377            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7378            .use_fips(false)
7379            .use_dual_stack(false)
7380            .accelerate(false)
7381            .build()
7382            .expect("invalid params");
7383        let resolver = crate::config::endpoint::DefaultResolver::new();
7384        let endpoint = resolver.resolve_endpoint(&params);
7385        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.us-west-1.amazonaws.com");
7386        assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.us-west-1.amazonaws.com")
7387    .property("authSchemes", vec![ {
7388        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7389        out.insert("name".to_string(), "sigv4a".to_string().into());
7390        out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7391        out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
7392        out.insert("disableDoubleEncoding".to_string(), true.into());
7393        out
7394    }.into()
7395    , {
7396        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7397        out.insert("name".to_string(), "sigv4".to_string().into());
7398        out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7399        out.insert("signingRegion".to_string(), "us-west-1".to_string().into());
7400        out.insert("disableDoubleEncoding".to_string(), true.into());
7401        out
7402    }.into()])
7403    .build());
7404    }
7405
7406    /// S3 Outposts bucketAlias Real Outpost Prod ap-east-1
7407    #[test]
7408    fn test_262() {
7409        let params = crate::config::endpoint::Params::builder()
7410            .region("ap-east-1".to_string())
7411            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7412            .use_fips(false)
7413            .use_dual_stack(false)
7414            .accelerate(false)
7415            .build()
7416            .expect("invalid params");
7417        let resolver = crate::config::endpoint::DefaultResolver::new();
7418        let endpoint = resolver.resolve_endpoint(&params);
7419        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.ap-east-1.amazonaws.com");
7420        assert_eq!(endpoint, ::aws_smithy_types::endpoint::Endpoint::builder().url("https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.ap-east-1.amazonaws.com")
7421    .property("authSchemes", vec![ {
7422        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7423        out.insert("name".to_string(), "sigv4a".to_string().into());
7424        out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7425        out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
7426        out.insert("disableDoubleEncoding".to_string(), true.into());
7427        out
7428    }.into()
7429    , {
7430        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7431        out.insert("name".to_string(), "sigv4".to_string().into());
7432        out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7433        out.insert("signingRegion".to_string(), "ap-east-1".to_string().into());
7434        out.insert("disableDoubleEncoding".to_string(), true.into());
7435        out
7436    }.into()])
7437    .build());
7438    }
7439
7440    /// S3 Outposts bucketAlias Ec2 Outpost Prod us-east-1
7441    #[test]
7442    fn test_263() {
7443        let params = crate::config::endpoint::Params::builder()
7444            .region("us-east-1".to_string())
7445            .bucket("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7446            .use_fips(false)
7447            .use_dual_stack(false)
7448            .accelerate(false)
7449            .build()
7450            .expect("invalid params");
7451        let resolver = crate::config::endpoint::DefaultResolver::new();
7452        let endpoint = resolver.resolve_endpoint(&params);
7453        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.us-east-1.amazonaws.com");
7454        assert_eq!(
7455            endpoint,
7456            ::aws_smithy_types::endpoint::Endpoint::builder()
7457                .url("https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.us-east-1.amazonaws.com")
7458                .property(
7459                    "authSchemes",
7460                    vec![
7461                        {
7462                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7463                            out.insert("name".to_string(), "sigv4a".to_string().into());
7464                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7465                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
7466                            out.insert("disableDoubleEncoding".to_string(), true.into());
7467                            out
7468                        }
7469                        .into(),
7470                        {
7471                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7472                            out.insert("name".to_string(), "sigv4".to_string().into());
7473                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7474                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7475                            out.insert("disableDoubleEncoding".to_string(), true.into());
7476                            out
7477                        }
7478                        .into()
7479                    ]
7480                )
7481                .build()
7482        );
7483    }
7484
7485    /// S3 Outposts bucketAlias Ec2 Outpost Prod me-south-1
7486    #[test]
7487    fn test_264() {
7488        let params = crate::config::endpoint::Params::builder()
7489            .region("me-south-1".to_string())
7490            .bucket("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7491            .use_fips(false)
7492            .use_dual_stack(false)
7493            .accelerate(false)
7494            .build()
7495            .expect("invalid params");
7496        let resolver = crate::config::endpoint::DefaultResolver::new();
7497        let endpoint = resolver.resolve_endpoint(&params);
7498        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.me-south-1.amazonaws.com");
7499        assert_eq!(
7500            endpoint,
7501            ::aws_smithy_types::endpoint::Endpoint::builder()
7502                .url("https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.me-south-1.amazonaws.com")
7503                .property(
7504                    "authSchemes",
7505                    vec![
7506                        {
7507                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7508                            out.insert("name".to_string(), "sigv4a".to_string().into());
7509                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7510                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
7511                            out.insert("disableDoubleEncoding".to_string(), true.into());
7512                            out
7513                        }
7514                        .into(),
7515                        {
7516                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7517                            out.insert("name".to_string(), "sigv4".to_string().into());
7518                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7519                            out.insert("signingRegion".to_string(), "me-south-1".to_string().into());
7520                            out.insert("disableDoubleEncoding".to_string(), true.into());
7521                            out
7522                        }
7523                        .into()
7524                    ]
7525                )
7526                .build()
7527        );
7528    }
7529
7530    /// S3 Outposts bucketAlias Real Outpost Beta
7531    #[test]
7532    fn test_265() {
7533        let params = crate::config::endpoint::Params::builder()
7534            .region("us-east-1".to_string())
7535            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
7536            .endpoint("https://example.amazonaws.com".to_string())
7537            .use_fips(false)
7538            .use_dual_stack(false)
7539            .accelerate(false)
7540            .build()
7541            .expect("invalid params");
7542        let resolver = crate::config::endpoint::DefaultResolver::new();
7543        let endpoint = resolver.resolve_endpoint(&params);
7544        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3.op-0b1d075431d83bebd.example.amazonaws.com");
7545        assert_eq!(
7546            endpoint,
7547            ::aws_smithy_types::endpoint::Endpoint::builder()
7548                .url("https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3.op-0b1d075431d83bebd.example.amazonaws.com")
7549                .property(
7550                    "authSchemes",
7551                    vec![
7552                        {
7553                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7554                            out.insert("name".to_string(), "sigv4a".to_string().into());
7555                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7556                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
7557                            out.insert("disableDoubleEncoding".to_string(), true.into());
7558                            out
7559                        }
7560                        .into(),
7561                        {
7562                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7563                            out.insert("name".to_string(), "sigv4".to_string().into());
7564                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7565                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7566                            out.insert("disableDoubleEncoding".to_string(), true.into());
7567                            out
7568                        }
7569                        .into()
7570                    ]
7571                )
7572                .build()
7573        );
7574    }
7575
7576    /// S3 Outposts bucketAlias Ec2 Outpost Beta
7577    #[test]
7578    fn test_266() {
7579        let params = crate::config::endpoint::Params::builder()
7580            .region("us-east-1".to_string())
7581            .bucket("161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3".to_string())
7582            .endpoint("https://example.amazonaws.com".to_string())
7583            .use_fips(false)
7584            .use_dual_stack(false)
7585            .accelerate(false)
7586            .build()
7587            .expect("invalid params");
7588        let resolver = crate::config::endpoint::DefaultResolver::new();
7589        let endpoint = resolver.resolve_endpoint(&params);
7590        let endpoint = endpoint
7591            .expect("Expected valid endpoint: https://161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3.ec2.example.amazonaws.com");
7592        assert_eq!(
7593            endpoint,
7594            ::aws_smithy_types::endpoint::Endpoint::builder()
7595                .url("https://161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3.ec2.example.amazonaws.com")
7596                .property(
7597                    "authSchemes",
7598                    vec![
7599                        {
7600                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7601                            out.insert("name".to_string(), "sigv4a".to_string().into());
7602                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7603                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
7604                            out.insert("disableDoubleEncoding".to_string(), true.into());
7605                            out
7606                        }
7607                        .into(),
7608                        {
7609                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7610                            out.insert("name".to_string(), "sigv4".to_string().into());
7611                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7612                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7613                            out.insert("disableDoubleEncoding".to_string(), true.into());
7614                            out
7615                        }
7616                        .into()
7617                    ]
7618                )
7619                .build()
7620        );
7621    }
7622
7623    /// S3 Outposts bucketAlias - No endpoint set for beta
7624    #[test]
7625    fn test_267() {
7626        let params = crate::config::endpoint::Params::builder()
7627            .region("us-east-1".to_string())
7628            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
7629            .use_fips(false)
7630            .use_dual_stack(false)
7631            .accelerate(false)
7632            .build()
7633            .expect("invalid params");
7634        let resolver = crate::config::endpoint::DefaultResolver::new();
7635        let endpoint = resolver.resolve_endpoint(&params);
7636        let error = endpoint.expect_err(
7637            "expected error: Expected a endpoint to be specified but no endpoint was found [S3 Outposts bucketAlias - No endpoint set for beta]",
7638        );
7639        assert_eq!(format!("{}", error), "Expected a endpoint to be specified but no endpoint was found")
7640    }
7641
7642    /// S3 Outposts invalid bucket name
7643    #[test]
7644    fn test_268() {
7645        let params = crate::config::endpoint::Params::builder()
7646            .region("us-east-1".to_string())
7647            .bucket("test-accessp-o0b1de75431d83bebd/8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
7648            .endpoint("https://example.amazonaws.com".to_string())
7649            .use_fips(false)
7650            .use_dual_stack(false)
7651            .accelerate(false)
7652            .build()
7653            .expect("invalid params");
7654        let resolver = crate::config::endpoint::DefaultResolver::new();
7655        let endpoint = resolver.resolve_endpoint(&params);
7656        let error =
7657            endpoint.expect_err("expected error: Invalid Outposts Bucket alias - it must be a valid bucket name. [S3 Outposts invalid bucket name]");
7658        assert_eq!(format!("{}", error), "Invalid Outposts Bucket alias - it must be a valid bucket name.")
7659    }
7660
7661    /// S3 Outposts bucketAlias Invalid hardware type
7662    #[test]
7663    fn test_269() {
7664        let params = crate::config::endpoint::Params::builder()
7665            .region("us-east-1".to_string())
7666            .bucket("test-accessp-h0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7667            .use_fips(false)
7668            .use_dual_stack(false)
7669            .accelerate(false)
7670            .build()
7671            .expect("invalid params");
7672        let resolver = crate::config::endpoint::DefaultResolver::new();
7673        let endpoint = resolver.resolve_endpoint(&params);
7674        let error = endpoint.expect_err(
7675            "expected error: Unrecognized hardware type: \"Expected hardware type o or e but got h\" [S3 Outposts bucketAlias Invalid hardware type]",
7676        );
7677        assert_eq!(
7678            format!("{}", error),
7679            "Unrecognized hardware type: \"Expected hardware type o or e but got h\""
7680        )
7681    }
7682
7683    /// S3 Outposts bucketAlias Special character in Outpost Arn
7684    #[test]
7685    fn test_270() {
7686        let params = crate::config::endpoint::Params::builder()
7687            .region("us-east-1".to_string())
7688            .bucket("test-accessp-o00000754%1d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7689            .use_fips(false)
7690            .use_dual_stack(false)
7691            .accelerate(false)
7692            .build()
7693            .expect("invalid params");
7694        let resolver = crate::config::endpoint::DefaultResolver::new();
7695        let endpoint = resolver.resolve_endpoint(&params);
7696        let error = endpoint.expect_err("expected error: Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`. [S3 Outposts bucketAlias Special character in Outpost Arn]");
7697        assert_eq!(
7698            format!("{}", error),
7699            "Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`."
7700        )
7701    }
7702
7703    /// S3 Outposts bucketAlias - No endpoint set for beta
7704    #[test]
7705    fn test_271() {
7706        let params = crate::config::endpoint::Params::builder()
7707            .region("us-east-1".to_string())
7708            .bucket("test-accessp-e0b1d075431d83bebde8xz5w8ijx1qzlbp3i3ebeta0--op-s3".to_string())
7709            .use_fips(false)
7710            .use_dual_stack(false)
7711            .accelerate(false)
7712            .build()
7713            .expect("invalid params");
7714        let resolver = crate::config::endpoint::DefaultResolver::new();
7715        let endpoint = resolver.resolve_endpoint(&params);
7716        let error = endpoint.expect_err(
7717            "expected error: Expected a endpoint to be specified but no endpoint was found [S3 Outposts bucketAlias - No endpoint set for beta]",
7718        );
7719        assert_eq!(format!("{}", error), "Expected a endpoint to be specified but no endpoint was found")
7720    }
7721
7722    /// S3 Snow with bucket
7723    #[test]
7724    fn test_272() {
7725        let params = crate::config::endpoint::Params::builder()
7726            .region("snow".to_string())
7727            .bucket("bucketName".to_string())
7728            .endpoint("http://10.0.1.12:433".to_string())
7729            .use_fips(false)
7730            .use_dual_stack(false)
7731            .accelerate(false)
7732            .build()
7733            .expect("invalid params");
7734        let resolver = crate::config::endpoint::DefaultResolver::new();
7735        let endpoint = resolver.resolve_endpoint(&params);
7736        let endpoint = endpoint.expect("Expected valid endpoint: http://10.0.1.12:433/bucketName");
7737        assert_eq!(
7738            endpoint,
7739            ::aws_smithy_types::endpoint::Endpoint::builder()
7740                .url("http://10.0.1.12:433/bucketName")
7741                .property(
7742                    "authSchemes",
7743                    vec![{
7744                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7745                        out.insert("name".to_string(), "sigv4".to_string().into());
7746                        out.insert("signingName".to_string(), "s3".to_string().into());
7747                        out.insert("signingRegion".to_string(), "snow".to_string().into());
7748                        out.insert("disableDoubleEncoding".to_string(), true.into());
7749                        out
7750                    }
7751                    .into()]
7752                )
7753                .build()
7754        );
7755    }
7756
7757    /// S3 Snow without bucket
7758    #[test]
7759    fn test_273() {
7760        let params = crate::config::endpoint::Params::builder()
7761            .region("snow".to_string())
7762            .endpoint("https://10.0.1.12:433".to_string())
7763            .use_fips(false)
7764            .use_dual_stack(false)
7765            .accelerate(false)
7766            .build()
7767            .expect("invalid params");
7768        let resolver = crate::config::endpoint::DefaultResolver::new();
7769        let endpoint = resolver.resolve_endpoint(&params);
7770        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.1.12:433");
7771        assert_eq!(
7772            endpoint,
7773            ::aws_smithy_types::endpoint::Endpoint::builder()
7774                .url("https://10.0.1.12:433")
7775                .property(
7776                    "authSchemes",
7777                    vec![{
7778                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7779                        out.insert("name".to_string(), "sigv4".to_string().into());
7780                        out.insert("signingName".to_string(), "s3".to_string().into());
7781                        out.insert("signingRegion".to_string(), "snow".to_string().into());
7782                        out.insert("disableDoubleEncoding".to_string(), true.into());
7783                        out
7784                    }
7785                    .into()]
7786                )
7787                .build()
7788        );
7789    }
7790
7791    /// S3 Snow no port
7792    #[test]
7793    fn test_274() {
7794        let params = crate::config::endpoint::Params::builder()
7795            .region("snow".to_string())
7796            .bucket("bucketName".to_string())
7797            .endpoint("http://10.0.1.12".to_string())
7798            .use_fips(false)
7799            .use_dual_stack(false)
7800            .accelerate(false)
7801            .build()
7802            .expect("invalid params");
7803        let resolver = crate::config::endpoint::DefaultResolver::new();
7804        let endpoint = resolver.resolve_endpoint(&params);
7805        let endpoint = endpoint.expect("Expected valid endpoint: http://10.0.1.12/bucketName");
7806        assert_eq!(
7807            endpoint,
7808            ::aws_smithy_types::endpoint::Endpoint::builder()
7809                .url("http://10.0.1.12/bucketName")
7810                .property(
7811                    "authSchemes",
7812                    vec![{
7813                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7814                        out.insert("name".to_string(), "sigv4".to_string().into());
7815                        out.insert("signingName".to_string(), "s3".to_string().into());
7816                        out.insert("signingRegion".to_string(), "snow".to_string().into());
7817                        out.insert("disableDoubleEncoding".to_string(), true.into());
7818                        out
7819                    }
7820                    .into()]
7821                )
7822                .build()
7823        );
7824    }
7825
7826    /// S3 Snow dns endpoint
7827    #[test]
7828    fn test_275() {
7829        let params = crate::config::endpoint::Params::builder()
7830            .region("snow".to_string())
7831            .bucket("bucketName".to_string())
7832            .endpoint("https://amazonaws.com".to_string())
7833            .use_fips(false)
7834            .use_dual_stack(false)
7835            .accelerate(false)
7836            .build()
7837            .expect("invalid params");
7838        let resolver = crate::config::endpoint::DefaultResolver::new();
7839        let endpoint = resolver.resolve_endpoint(&params);
7840        let endpoint = endpoint.expect("Expected valid endpoint: https://amazonaws.com/bucketName");
7841        assert_eq!(
7842            endpoint,
7843            ::aws_smithy_types::endpoint::Endpoint::builder()
7844                .url("https://amazonaws.com/bucketName")
7845                .property(
7846                    "authSchemes",
7847                    vec![{
7848                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7849                        out.insert("name".to_string(), "sigv4".to_string().into());
7850                        out.insert("signingName".to_string(), "s3".to_string().into());
7851                        out.insert("signingRegion".to_string(), "snow".to_string().into());
7852                        out.insert("disableDoubleEncoding".to_string(), true.into());
7853                        out
7854                    }
7855                    .into()]
7856                )
7857                .build()
7858        );
7859    }
7860
7861    /// Data Plane with short zone name
7862    #[test]
7863    fn test_276() {
7864        let params = crate::config::endpoint::Params::builder()
7865            .region("us-east-1".to_string())
7866            .bucket("mybucket--abcd-ab1--x-s3".to_string())
7867            .use_fips(false)
7868            .use_dual_stack(false)
7869            .accelerate(false)
7870            .use_s3_express_control_endpoint(false)
7871            .build()
7872            .expect("invalid params");
7873        let resolver = crate::config::endpoint::DefaultResolver::new();
7874        let endpoint = resolver.resolve_endpoint(&params);
7875        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com");
7876        assert_eq!(
7877            endpoint,
7878            ::aws_smithy_types::endpoint::Endpoint::builder()
7879                .url("https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com")
7880                .property(
7881                    "authSchemes",
7882                    vec![{
7883                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7884                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7885                        out.insert("signingName".to_string(), "s3express".to_string().into());
7886                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7887                        out.insert("disableDoubleEncoding".to_string(), true.into());
7888                        out
7889                    }
7890                    .into()]
7891                )
7892                .property("backend", "S3Express".to_string())
7893                .build()
7894        );
7895    }
7896
7897    /// Data Plane with short zone name china region
7898    #[test]
7899    fn test_277() {
7900        let params = crate::config::endpoint::Params::builder()
7901            .region("cn-north-1".to_string())
7902            .bucket("mybucket--abcd-ab1--x-s3".to_string())
7903            .use_fips(false)
7904            .use_dual_stack(false)
7905            .accelerate(false)
7906            .use_s3_express_control_endpoint(false)
7907            .build()
7908            .expect("invalid params");
7909        let resolver = crate::config::endpoint::DefaultResolver::new();
7910        let endpoint = resolver.resolve_endpoint(&params);
7911        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn");
7912        assert_eq!(
7913            endpoint,
7914            ::aws_smithy_types::endpoint::Endpoint::builder()
7915                .url("https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn")
7916                .property(
7917                    "authSchemes",
7918                    vec![{
7919                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7920                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7921                        out.insert("signingName".to_string(), "s3express".to_string().into());
7922                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
7923                        out.insert("disableDoubleEncoding".to_string(), true.into());
7924                        out
7925                    }
7926                    .into()]
7927                )
7928                .property("backend", "S3Express".to_string())
7929                .build()
7930        );
7931    }
7932
7933    /// Data Plane with short zone name with AP
7934    #[test]
7935    fn test_278() {
7936        let params = crate::config::endpoint::Params::builder()
7937            .region("us-east-1".to_string())
7938            .bucket("myaccesspoint--abcd-ab1--xa-s3".to_string())
7939            .use_fips(false)
7940            .use_dual_stack(false)
7941            .accelerate(false)
7942            .use_s3_express_control_endpoint(false)
7943            .build()
7944            .expect("invalid params");
7945        let resolver = crate::config::endpoint::DefaultResolver::new();
7946        let endpoint = resolver.resolve_endpoint(&params);
7947        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.us-east-1.amazonaws.com");
7948        assert_eq!(
7949            endpoint,
7950            ::aws_smithy_types::endpoint::Endpoint::builder()
7951                .url("https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.us-east-1.amazonaws.com")
7952                .property(
7953                    "authSchemes",
7954                    vec![{
7955                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7956                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7957                        out.insert("signingName".to_string(), "s3express".to_string().into());
7958                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7959                        out.insert("disableDoubleEncoding".to_string(), true.into());
7960                        out
7961                    }
7962                    .into()]
7963                )
7964                .property("backend", "S3Express".to_string())
7965                .build()
7966        );
7967    }
7968
7969    /// Data Plane with short zone name with AP china region
7970    #[test]
7971    fn test_279() {
7972        let params = crate::config::endpoint::Params::builder()
7973            .region("cn-north-1".to_string())
7974            .bucket("myaccesspoint--abcd-ab1--xa-s3".to_string())
7975            .use_fips(false)
7976            .use_dual_stack(false)
7977            .accelerate(false)
7978            .use_s3_express_control_endpoint(false)
7979            .build()
7980            .expect("invalid params");
7981        let resolver = crate::config::endpoint::DefaultResolver::new();
7982        let endpoint = resolver.resolve_endpoint(&params);
7983        let endpoint =
7984            endpoint.expect("Expected valid endpoint: https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn");
7985        assert_eq!(
7986            endpoint,
7987            ::aws_smithy_types::endpoint::Endpoint::builder()
7988                .url("https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn")
7989                .property(
7990                    "authSchemes",
7991                    vec![{
7992                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7993                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7994                        out.insert("signingName".to_string(), "s3express".to_string().into());
7995                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
7996                        out.insert("disableDoubleEncoding".to_string(), true.into());
7997                        out
7998                    }
7999                    .into()]
8000                )
8001                .property("backend", "S3Express".to_string())
8002                .build()
8003        );
8004    }
8005
8006    /// Data Plane with short zone names (13 chars)
8007    #[test]
8008    fn test_280() {
8009        let params = crate::config::endpoint::Params::builder()
8010            .region("us-west-2".to_string())
8011            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
8012            .use_fips(false)
8013            .use_dual_stack(false)
8014            .accelerate(false)
8015            .use_s3_express_control_endpoint(false)
8016            .build()
8017            .expect("invalid params");
8018        let resolver = crate::config::endpoint::DefaultResolver::new();
8019        let endpoint = resolver.resolve_endpoint(&params);
8020        let endpoint =
8021            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
8022        assert_eq!(
8023            endpoint,
8024            ::aws_smithy_types::endpoint::Endpoint::builder()
8025                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
8026                .property(
8027                    "authSchemes",
8028                    vec![{
8029                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8030                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8031                        out.insert("signingName".to_string(), "s3express".to_string().into());
8032                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8033                        out.insert("disableDoubleEncoding".to_string(), true.into());
8034                        out
8035                    }
8036                    .into()]
8037                )
8038                .property("backend", "S3Express".to_string())
8039                .build()
8040        );
8041    }
8042
8043    /// Data Plane with short zone names (13 chars) with AP
8044    #[test]
8045    fn test_281() {
8046        let params = crate::config::endpoint::Params::builder()
8047            .region("us-west-2".to_string())
8048            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
8049            .use_fips(false)
8050            .use_dual_stack(false)
8051            .accelerate(false)
8052            .use_s3_express_control_endpoint(false)
8053            .build()
8054            .expect("invalid params");
8055        let resolver = crate::config::endpoint::DefaultResolver::new();
8056        let endpoint = resolver.resolve_endpoint(&params);
8057        let endpoint =
8058            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
8059        assert_eq!(
8060            endpoint,
8061            ::aws_smithy_types::endpoint::Endpoint::builder()
8062                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
8063                .property(
8064                    "authSchemes",
8065                    vec![{
8066                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8067                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8068                        out.insert("signingName".to_string(), "s3express".to_string().into());
8069                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8070                        out.insert("disableDoubleEncoding".to_string(), true.into());
8071                        out
8072                    }
8073                    .into()]
8074                )
8075                .property("backend", "S3Express".to_string())
8076                .build()
8077        );
8078    }
8079
8080    /// Data Plane with medium zone names (14 chars)
8081    #[test]
8082    fn test_282() {
8083        let params = crate::config::endpoint::Params::builder()
8084            .region("us-west-2".to_string())
8085            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
8086            .use_fips(false)
8087            .use_dual_stack(false)
8088            .accelerate(false)
8089            .use_s3_express_control_endpoint(false)
8090            .build()
8091            .expect("invalid params");
8092        let resolver = crate::config::endpoint::DefaultResolver::new();
8093        let endpoint = resolver.resolve_endpoint(&params);
8094        let endpoint =
8095            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
8096        assert_eq!(
8097            endpoint,
8098            ::aws_smithy_types::endpoint::Endpoint::builder()
8099                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
8100                .property(
8101                    "authSchemes",
8102                    vec![{
8103                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8104                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8105                        out.insert("signingName".to_string(), "s3express".to_string().into());
8106                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8107                        out.insert("disableDoubleEncoding".to_string(), true.into());
8108                        out
8109                    }
8110                    .into()]
8111                )
8112                .property("backend", "S3Express".to_string())
8113                .build()
8114        );
8115    }
8116
8117    /// Data Plane with medium zone names (14 chars) with AP
8118    #[test]
8119    fn test_283() {
8120        let params = crate::config::endpoint::Params::builder()
8121            .region("us-west-2".to_string())
8122            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
8123            .use_fips(false)
8124            .use_dual_stack(false)
8125            .accelerate(false)
8126            .use_s3_express_control_endpoint(false)
8127            .build()
8128            .expect("invalid params");
8129        let resolver = crate::config::endpoint::DefaultResolver::new();
8130        let endpoint = resolver.resolve_endpoint(&params);
8131        let endpoint =
8132            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
8133        assert_eq!(
8134            endpoint,
8135            ::aws_smithy_types::endpoint::Endpoint::builder()
8136                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
8137                .property(
8138                    "authSchemes",
8139                    vec![{
8140                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8141                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8142                        out.insert("signingName".to_string(), "s3express".to_string().into());
8143                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8144                        out.insert("disableDoubleEncoding".to_string(), true.into());
8145                        out
8146                    }
8147                    .into()]
8148                )
8149                .property("backend", "S3Express".to_string())
8150                .build()
8151        );
8152    }
8153
8154    /// Data Plane with long zone names (20 chars)
8155    #[test]
8156    fn test_284() {
8157        let params = crate::config::endpoint::Params::builder()
8158            .region("us-west-2".to_string())
8159            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
8160            .use_fips(false)
8161            .use_dual_stack(false)
8162            .accelerate(false)
8163            .use_s3_express_control_endpoint(false)
8164            .build()
8165            .expect("invalid params");
8166        let resolver = crate::config::endpoint::DefaultResolver::new();
8167        let endpoint = resolver.resolve_endpoint(&params);
8168        let endpoint = endpoint
8169            .expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com");
8170        assert_eq!(
8171            endpoint,
8172            ::aws_smithy_types::endpoint::Endpoint::builder()
8173                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
8174                .property(
8175                    "authSchemes",
8176                    vec![{
8177                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8178                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8179                        out.insert("signingName".to_string(), "s3express".to_string().into());
8180                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8181                        out.insert("disableDoubleEncoding".to_string(), true.into());
8182                        out
8183                    }
8184                    .into()]
8185                )
8186                .property("backend", "S3Express".to_string())
8187                .build()
8188        );
8189    }
8190
8191    /// Data Plane with long zone names (20 chars)
8192    #[test]
8193    fn test_285() {
8194        let params = crate::config::endpoint::Params::builder()
8195            .region("us-west-2".to_string())
8196            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
8197            .use_fips(false)
8198            .use_dual_stack(false)
8199            .accelerate(false)
8200            .use_s3_express_control_endpoint(false)
8201            .build()
8202            .expect("invalid params");
8203        let resolver = crate::config::endpoint::DefaultResolver::new();
8204        let endpoint = resolver.resolve_endpoint(&params);
8205        let endpoint = endpoint.expect(
8206            "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com",
8207        );
8208        assert_eq!(
8209            endpoint,
8210            ::aws_smithy_types::endpoint::Endpoint::builder()
8211                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
8212                .property(
8213                    "authSchemes",
8214                    vec![{
8215                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8216                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8217                        out.insert("signingName".to_string(), "s3express".to_string().into());
8218                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8219                        out.insert("disableDoubleEncoding".to_string(), true.into());
8220                        out
8221                    }
8222                    .into()]
8223                )
8224                .property("backend", "S3Express".to_string())
8225                .build()
8226        );
8227    }
8228
8229    /// Data Plane with short zone fips
8230    #[test]
8231    fn test_286() {
8232        let params = crate::config::endpoint::Params::builder()
8233            .region("us-east-1".to_string())
8234            .bucket("mybucket--test-ab1--x-s3".to_string())
8235            .use_fips(true)
8236            .use_dual_stack(false)
8237            .accelerate(false)
8238            .use_s3_express_control_endpoint(false)
8239            .build()
8240            .expect("invalid params");
8241        let resolver = crate::config::endpoint::DefaultResolver::new();
8242        let endpoint = resolver.resolve_endpoint(&params);
8243        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test-ab1--x-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com");
8244        assert_eq!(
8245            endpoint,
8246            ::aws_smithy_types::endpoint::Endpoint::builder()
8247                .url("https://mybucket--test-ab1--x-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com")
8248                .property(
8249                    "authSchemes",
8250                    vec![{
8251                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8252                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8253                        out.insert("signingName".to_string(), "s3express".to_string().into());
8254                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
8255                        out.insert("disableDoubleEncoding".to_string(), true.into());
8256                        out
8257                    }
8258                    .into()]
8259                )
8260                .property("backend", "S3Express".to_string())
8261                .build()
8262        );
8263    }
8264
8265    /// Data Plane with short zone fips china region
8266    #[test]
8267    fn test_287() {
8268        let params = crate::config::endpoint::Params::builder()
8269            .region("cn-north-1".to_string())
8270            .bucket("mybucket--test-ab1--x-s3".to_string())
8271            .use_fips(true)
8272            .use_dual_stack(false)
8273            .accelerate(false)
8274            .use_s3_express_control_endpoint(false)
8275            .build()
8276            .expect("invalid params");
8277        let resolver = crate::config::endpoint::DefaultResolver::new();
8278        let endpoint = resolver.resolve_endpoint(&params);
8279        let error = endpoint.expect_err("expected error: Partition does not support FIPS [Data Plane with short zone fips china region]");
8280        assert_eq!(format!("{}", error), "Partition does not support FIPS")
8281    }
8282
8283    /// Data Plane with short zone fips with AP
8284    #[test]
8285    fn test_288() {
8286        let params = crate::config::endpoint::Params::builder()
8287            .region("us-east-1".to_string())
8288            .bucket("myaccesspoint--test-ab1--xa-s3".to_string())
8289            .use_fips(true)
8290            .use_dual_stack(false)
8291            .accelerate(false)
8292            .use_s3_express_control_endpoint(false)
8293            .build()
8294            .expect("invalid params");
8295        let resolver = crate::config::endpoint::DefaultResolver::new();
8296        let endpoint = resolver.resolve_endpoint(&params);
8297        let endpoint =
8298            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test-ab1--xa-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com");
8299        assert_eq!(
8300            endpoint,
8301            ::aws_smithy_types::endpoint::Endpoint::builder()
8302                .url("https://myaccesspoint--test-ab1--xa-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com")
8303                .property(
8304                    "authSchemes",
8305                    vec![{
8306                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8307                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8308                        out.insert("signingName".to_string(), "s3express".to_string().into());
8309                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
8310                        out.insert("disableDoubleEncoding".to_string(), true.into());
8311                        out
8312                    }
8313                    .into()]
8314                )
8315                .property("backend", "S3Express".to_string())
8316                .build()
8317        );
8318    }
8319
8320    /// Data Plane with short zone fips with AP china region
8321    #[test]
8322    fn test_289() {
8323        let params = crate::config::endpoint::Params::builder()
8324            .region("cn-north-1".to_string())
8325            .bucket("myaccesspoint--test-ab1--xa-s3".to_string())
8326            .use_fips(true)
8327            .use_dual_stack(false)
8328            .accelerate(false)
8329            .use_s3_express_control_endpoint(false)
8330            .build()
8331            .expect("invalid params");
8332        let resolver = crate::config::endpoint::DefaultResolver::new();
8333        let endpoint = resolver.resolve_endpoint(&params);
8334        let error = endpoint.expect_err("expected error: Partition does not support FIPS [Data Plane with short zone fips with AP china region]");
8335        assert_eq!(format!("{}", error), "Partition does not support FIPS")
8336    }
8337
8338    /// Data Plane with short zone (13 chars) fips
8339    #[test]
8340    fn test_290() {
8341        let params = crate::config::endpoint::Params::builder()
8342            .region("us-west-2".to_string())
8343            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
8344            .use_fips(true)
8345            .use_dual_stack(false)
8346            .accelerate(false)
8347            .use_s3_express_control_endpoint(false)
8348            .build()
8349            .expect("invalid params");
8350        let resolver = crate::config::endpoint::DefaultResolver::new();
8351        let endpoint = resolver.resolve_endpoint(&params);
8352        let endpoint =
8353            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
8354        assert_eq!(
8355            endpoint,
8356            ::aws_smithy_types::endpoint::Endpoint::builder()
8357                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
8358                .property(
8359                    "authSchemes",
8360                    vec![{
8361                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8362                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8363                        out.insert("signingName".to_string(), "s3express".to_string().into());
8364                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8365                        out.insert("disableDoubleEncoding".to_string(), true.into());
8366                        out
8367                    }
8368                    .into()]
8369                )
8370                .property("backend", "S3Express".to_string())
8371                .build()
8372        );
8373    }
8374
8375    /// Data Plane with short zone (13 chars) fips with AP
8376    #[test]
8377    fn test_291() {
8378        let params = crate::config::endpoint::Params::builder()
8379            .region("us-west-2".to_string())
8380            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
8381            .use_fips(true)
8382            .use_dual_stack(false)
8383            .accelerate(false)
8384            .use_s3_express_control_endpoint(false)
8385            .build()
8386            .expect("invalid params");
8387        let resolver = crate::config::endpoint::DefaultResolver::new();
8388        let endpoint = resolver.resolve_endpoint(&params);
8389        let endpoint = endpoint
8390            .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
8391        assert_eq!(
8392            endpoint,
8393            ::aws_smithy_types::endpoint::Endpoint::builder()
8394                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
8395                .property(
8396                    "authSchemes",
8397                    vec![{
8398                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8399                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8400                        out.insert("signingName".to_string(), "s3express".to_string().into());
8401                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8402                        out.insert("disableDoubleEncoding".to_string(), true.into());
8403                        out
8404                    }
8405                    .into()]
8406                )
8407                .property("backend", "S3Express".to_string())
8408                .build()
8409        );
8410    }
8411
8412    /// Data Plane with medium zone (14 chars) fips
8413    #[test]
8414    fn test_292() {
8415        let params = crate::config::endpoint::Params::builder()
8416            .region("us-west-2".to_string())
8417            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
8418            .use_fips(true)
8419            .use_dual_stack(false)
8420            .accelerate(false)
8421            .use_s3_express_control_endpoint(false)
8422            .build()
8423            .expect("invalid params");
8424        let resolver = crate::config::endpoint::DefaultResolver::new();
8425        let endpoint = resolver.resolve_endpoint(&params);
8426        let endpoint =
8427            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
8428        assert_eq!(
8429            endpoint,
8430            ::aws_smithy_types::endpoint::Endpoint::builder()
8431                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
8432                .property(
8433                    "authSchemes",
8434                    vec![{
8435                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8436                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8437                        out.insert("signingName".to_string(), "s3express".to_string().into());
8438                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8439                        out.insert("disableDoubleEncoding".to_string(), true.into());
8440                        out
8441                    }
8442                    .into()]
8443                )
8444                .property("backend", "S3Express".to_string())
8445                .build()
8446        );
8447    }
8448
8449    /// Data Plane with medium zone (14 chars) fips with AP
8450    #[test]
8451    fn test_293() {
8452        let params = crate::config::endpoint::Params::builder()
8453            .region("us-west-2".to_string())
8454            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
8455            .use_fips(true)
8456            .use_dual_stack(false)
8457            .accelerate(false)
8458            .use_s3_express_control_endpoint(false)
8459            .build()
8460            .expect("invalid params");
8461        let resolver = crate::config::endpoint::DefaultResolver::new();
8462        let endpoint = resolver.resolve_endpoint(&params);
8463        let endpoint = endpoint
8464            .expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
8465        assert_eq!(
8466            endpoint,
8467            ::aws_smithy_types::endpoint::Endpoint::builder()
8468                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
8469                .property(
8470                    "authSchemes",
8471                    vec![{
8472                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8473                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8474                        out.insert("signingName".to_string(), "s3express".to_string().into());
8475                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8476                        out.insert("disableDoubleEncoding".to_string(), true.into());
8477                        out
8478                    }
8479                    .into()]
8480                )
8481                .property("backend", "S3Express".to_string())
8482                .build()
8483        );
8484    }
8485
8486    /// Data Plane with long zone (20 chars) fips
8487    #[test]
8488    fn test_294() {
8489        let params = crate::config::endpoint::Params::builder()
8490            .region("us-west-2".to_string())
8491            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
8492            .use_fips(true)
8493            .use_dual_stack(false)
8494            .accelerate(false)
8495            .use_s3_express_control_endpoint(false)
8496            .build()
8497            .expect("invalid params");
8498        let resolver = crate::config::endpoint::DefaultResolver::new();
8499        let endpoint = resolver.resolve_endpoint(&params);
8500        let endpoint = endpoint.expect(
8501            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
8502        );
8503        assert_eq!(
8504            endpoint,
8505            ::aws_smithy_types::endpoint::Endpoint::builder()
8506                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
8507                .property(
8508                    "authSchemes",
8509                    vec![{
8510                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8511                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8512                        out.insert("signingName".to_string(), "s3express".to_string().into());
8513                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8514                        out.insert("disableDoubleEncoding".to_string(), true.into());
8515                        out
8516                    }
8517                    .into()]
8518                )
8519                .property("backend", "S3Express".to_string())
8520                .build()
8521        );
8522    }
8523
8524    /// Data Plane with long zone (20 chars) fips with AP
8525    #[test]
8526    fn test_295() {
8527        let params = crate::config::endpoint::Params::builder()
8528            .region("us-west-2".to_string())
8529            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
8530            .use_fips(true)
8531            .use_dual_stack(false)
8532            .accelerate(false)
8533            .use_s3_express_control_endpoint(false)
8534            .build()
8535            .expect("invalid params");
8536        let resolver = crate::config::endpoint::DefaultResolver::new();
8537        let endpoint = resolver.resolve_endpoint(&params);
8538        let endpoint = endpoint.expect(
8539            "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
8540        );
8541        assert_eq!(
8542            endpoint,
8543            ::aws_smithy_types::endpoint::Endpoint::builder()
8544                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
8545                .property(
8546                    "authSchemes",
8547                    vec![{
8548                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8549                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8550                        out.insert("signingName".to_string(), "s3express".to_string().into());
8551                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8552                        out.insert("disableDoubleEncoding".to_string(), true.into());
8553                        out
8554                    }
8555                    .into()]
8556                )
8557                .property("backend", "S3Express".to_string())
8558                .build()
8559        );
8560    }
8561
8562    /// Data Plane with long AZ
8563    #[test]
8564    fn test_296() {
8565        let params = crate::config::endpoint::Params::builder()
8566            .region("us-west-2".to_string())
8567            .bucket("mybucket--test1-az1--x-s3".to_string())
8568            .use_fips(false)
8569            .use_dual_stack(false)
8570            .accelerate(false)
8571            .use_s3_express_control_endpoint(false)
8572            .build()
8573            .expect("invalid params");
8574        let resolver = crate::config::endpoint::DefaultResolver::new();
8575        let endpoint = resolver.resolve_endpoint(&params);
8576        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com");
8577        assert_eq!(
8578            endpoint,
8579            ::aws_smithy_types::endpoint::Endpoint::builder()
8580                .url("https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com")
8581                .property(
8582                    "authSchemes",
8583                    vec![{
8584                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8585                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8586                        out.insert("signingName".to_string(), "s3express".to_string().into());
8587                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8588                        out.insert("disableDoubleEncoding".to_string(), true.into());
8589                        out
8590                    }
8591                    .into()]
8592                )
8593                .property("backend", "S3Express".to_string())
8594                .build()
8595        );
8596    }
8597
8598    /// Data Plane with long AZ with AP
8599    #[test]
8600    fn test_297() {
8601        let params = crate::config::endpoint::Params::builder()
8602            .region("us-west-2".to_string())
8603            .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
8604            .use_fips(false)
8605            .use_dual_stack(false)
8606            .accelerate(false)
8607            .use_s3_express_control_endpoint(false)
8608            .build()
8609            .expect("invalid params");
8610        let resolver = crate::config::endpoint::DefaultResolver::new();
8611        let endpoint = resolver.resolve_endpoint(&params);
8612        let endpoint =
8613            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com");
8614        assert_eq!(
8615            endpoint,
8616            ::aws_smithy_types::endpoint::Endpoint::builder()
8617                .url("https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com")
8618                .property(
8619                    "authSchemes",
8620                    vec![{
8621                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8622                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8623                        out.insert("signingName".to_string(), "s3express".to_string().into());
8624                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8625                        out.insert("disableDoubleEncoding".to_string(), true.into());
8626                        out
8627                    }
8628                    .into()]
8629                )
8630                .property("backend", "S3Express".to_string())
8631                .build()
8632        );
8633    }
8634
8635    /// Data Plane with long AZ fips
8636    #[test]
8637    fn test_298() {
8638        let params = crate::config::endpoint::Params::builder()
8639            .region("us-west-2".to_string())
8640            .bucket("mybucket--test1-az1--x-s3".to_string())
8641            .use_fips(true)
8642            .use_dual_stack(false)
8643            .accelerate(false)
8644            .use_s3_express_control_endpoint(false)
8645            .build()
8646            .expect("invalid params");
8647        let resolver = crate::config::endpoint::DefaultResolver::new();
8648        let endpoint = resolver.resolve_endpoint(&params);
8649        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
8650        assert_eq!(
8651            endpoint,
8652            ::aws_smithy_types::endpoint::Endpoint::builder()
8653                .url("https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
8654                .property(
8655                    "authSchemes",
8656                    vec![{
8657                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8658                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8659                        out.insert("signingName".to_string(), "s3express".to_string().into());
8660                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8661                        out.insert("disableDoubleEncoding".to_string(), true.into());
8662                        out
8663                    }
8664                    .into()]
8665                )
8666                .property("backend", "S3Express".to_string())
8667                .build()
8668        );
8669    }
8670
8671    /// Data Plane with long AZ fips with AP
8672    #[test]
8673    fn test_299() {
8674        let params = crate::config::endpoint::Params::builder()
8675            .region("us-west-2".to_string())
8676            .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
8677            .use_fips(true)
8678            .use_dual_stack(false)
8679            .accelerate(false)
8680            .use_s3_express_control_endpoint(false)
8681            .build()
8682            .expect("invalid params");
8683        let resolver = crate::config::endpoint::DefaultResolver::new();
8684        let endpoint = resolver.resolve_endpoint(&params);
8685        let endpoint =
8686            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
8687        assert_eq!(
8688            endpoint,
8689            ::aws_smithy_types::endpoint::Endpoint::builder()
8690                .url("https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
8691                .property(
8692                    "authSchemes",
8693                    vec![{
8694                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8695                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8696                        out.insert("signingName".to_string(), "s3express".to_string().into());
8697                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8698                        out.insert("disableDoubleEncoding".to_string(), true.into());
8699                        out
8700                    }
8701                    .into()]
8702                )
8703                .property("backend", "S3Express".to_string())
8704                .build()
8705        );
8706    }
8707
8708    /// Control plane with short AZ bucket
8709    #[test]
8710    fn test_300() {
8711        let params = crate::config::endpoint::Params::builder()
8712            .region("us-east-1".to_string())
8713            .bucket("mybucket--test-ab1--x-s3".to_string())
8714            .use_fips(false)
8715            .use_dual_stack(false)
8716            .accelerate(false)
8717            .use_s3_express_control_endpoint(true)
8718            .disable_s3_express_session_auth(false)
8719            .build()
8720            .expect("invalid params");
8721        let resolver = crate::config::endpoint::DefaultResolver::new();
8722        let endpoint = resolver.resolve_endpoint(&params);
8723        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
8724        assert_eq!(
8725            endpoint,
8726            ::aws_smithy_types::endpoint::Endpoint::builder()
8727                .url("https://s3express-control.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
8728                .property(
8729                    "authSchemes",
8730                    vec![{
8731                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8732                        out.insert("name".to_string(), "sigv4".to_string().into());
8733                        out.insert("signingName".to_string(), "s3express".to_string().into());
8734                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
8735                        out.insert("disableDoubleEncoding".to_string(), true.into());
8736                        out
8737                    }
8738                    .into()]
8739                )
8740                .property("backend", "S3Express".to_string())
8741                .build()
8742        );
8743    }
8744
8745    /// Control plane with short AZ bucket china region
8746    #[test]
8747    fn test_301() {
8748        let params = crate::config::endpoint::Params::builder()
8749            .region("cn-north-1".to_string())
8750            .bucket("mybucket--test-ab1--x-s3".to_string())
8751            .use_fips(false)
8752            .use_dual_stack(false)
8753            .accelerate(false)
8754            .use_s3_express_control_endpoint(true)
8755            .disable_s3_express_session_auth(false)
8756            .build()
8757            .expect("invalid params");
8758        let resolver = crate::config::endpoint::DefaultResolver::new();
8759        let endpoint = resolver.resolve_endpoint(&params);
8760        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.cn-north-1.amazonaws.com.cn/mybucket--test-ab1--x-s3");
8761        assert_eq!(
8762            endpoint,
8763            ::aws_smithy_types::endpoint::Endpoint::builder()
8764                .url("https://s3express-control.cn-north-1.amazonaws.com.cn/mybucket--test-ab1--x-s3")
8765                .property(
8766                    "authSchemes",
8767                    vec![{
8768                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8769                        out.insert("name".to_string(), "sigv4".to_string().into());
8770                        out.insert("signingName".to_string(), "s3express".to_string().into());
8771                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
8772                        out.insert("disableDoubleEncoding".to_string(), true.into());
8773                        out
8774                    }
8775                    .into()]
8776                )
8777                .property("backend", "S3Express".to_string())
8778                .build()
8779        );
8780    }
8781
8782    /// Control plane with short AZ bucket and fips
8783    #[test]
8784    fn test_302() {
8785        let params = crate::config::endpoint::Params::builder()
8786            .region("us-east-1".to_string())
8787            .bucket("mybucket--test-ab1--x-s3".to_string())
8788            .use_fips(true)
8789            .use_dual_stack(false)
8790            .accelerate(false)
8791            .use_s3_express_control_endpoint(true)
8792            .disable_s3_express_session_auth(false)
8793            .build()
8794            .expect("invalid params");
8795        let resolver = crate::config::endpoint::DefaultResolver::new();
8796        let endpoint = resolver.resolve_endpoint(&params);
8797        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
8798        assert_eq!(
8799            endpoint,
8800            ::aws_smithy_types::endpoint::Endpoint::builder()
8801                .url("https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
8802                .property(
8803                    "authSchemes",
8804                    vec![{
8805                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8806                        out.insert("name".to_string(), "sigv4".to_string().into());
8807                        out.insert("signingName".to_string(), "s3express".to_string().into());
8808                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
8809                        out.insert("disableDoubleEncoding".to_string(), true.into());
8810                        out
8811                    }
8812                    .into()]
8813                )
8814                .property("backend", "S3Express".to_string())
8815                .build()
8816        );
8817    }
8818
8819    /// Control plane with short AZ bucket and fips china region
8820    #[test]
8821    fn test_303() {
8822        let params = crate::config::endpoint::Params::builder()
8823            .region("cn-north-1".to_string())
8824            .bucket("mybucket--test-ab1--x-s3".to_string())
8825            .use_fips(true)
8826            .use_dual_stack(false)
8827            .accelerate(false)
8828            .use_s3_express_control_endpoint(true)
8829            .disable_s3_express_session_auth(false)
8830            .build()
8831            .expect("invalid params");
8832        let resolver = crate::config::endpoint::DefaultResolver::new();
8833        let endpoint = resolver.resolve_endpoint(&params);
8834        let error = endpoint.expect_err("expected error: Partition does not support FIPS [Control plane with short AZ bucket and fips china region]");
8835        assert_eq!(format!("{}", error), "Partition does not support FIPS")
8836    }
8837
8838    /// Control plane without bucket
8839    #[test]
8840    fn test_304() {
8841        let params = crate::config::endpoint::Params::builder()
8842            .region("us-east-1".to_string())
8843            .use_fips(false)
8844            .use_dual_stack(false)
8845            .accelerate(false)
8846            .use_s3_express_control_endpoint(true)
8847            .disable_s3_express_session_auth(false)
8848            .build()
8849            .expect("invalid params");
8850        let resolver = crate::config::endpoint::DefaultResolver::new();
8851        let endpoint = resolver.resolve_endpoint(&params);
8852        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com");
8853        assert_eq!(
8854            endpoint,
8855            ::aws_smithy_types::endpoint::Endpoint::builder()
8856                .url("https://s3express-control.us-east-1.amazonaws.com")
8857                .property(
8858                    "authSchemes",
8859                    vec![{
8860                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8861                        out.insert("name".to_string(), "sigv4".to_string().into());
8862                        out.insert("signingName".to_string(), "s3express".to_string().into());
8863                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
8864                        out.insert("disableDoubleEncoding".to_string(), true.into());
8865                        out
8866                    }
8867                    .into()]
8868                )
8869                .property("backend", "S3Express".to_string())
8870                .build()
8871        );
8872    }
8873
8874    /// Control plane without bucket and fips
8875    #[test]
8876    fn test_305() {
8877        let params = crate::config::endpoint::Params::builder()
8878            .region("us-east-1".to_string())
8879            .use_fips(true)
8880            .use_dual_stack(false)
8881            .accelerate(false)
8882            .use_s3_express_control_endpoint(true)
8883            .disable_s3_express_session_auth(false)
8884            .build()
8885            .expect("invalid params");
8886        let resolver = crate::config::endpoint::DefaultResolver::new();
8887        let endpoint = resolver.resolve_endpoint(&params);
8888        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com");
8889        assert_eq!(
8890            endpoint,
8891            ::aws_smithy_types::endpoint::Endpoint::builder()
8892                .url("https://s3express-control-fips.us-east-1.amazonaws.com")
8893                .property(
8894                    "authSchemes",
8895                    vec![{
8896                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8897                        out.insert("name".to_string(), "sigv4".to_string().into());
8898                        out.insert("signingName".to_string(), "s3express".to_string().into());
8899                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
8900                        out.insert("disableDoubleEncoding".to_string(), true.into());
8901                        out
8902                    }
8903                    .into()]
8904                )
8905                .property("backend", "S3Express".to_string())
8906                .build()
8907        );
8908    }
8909
8910    /// Data Plane sigv4 auth with short AZ
8911    #[test]
8912    fn test_306() {
8913        let params = crate::config::endpoint::Params::builder()
8914            .region("us-west-2".to_string())
8915            .bucket("mybucket--usw2-az1--x-s3".to_string())
8916            .use_fips(false)
8917            .use_dual_stack(false)
8918            .accelerate(false)
8919            .disable_s3_express_session_auth(true)
8920            .build()
8921            .expect("invalid params");
8922        let resolver = crate::config::endpoint::DefaultResolver::new();
8923        let endpoint = resolver.resolve_endpoint(&params);
8924        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com");
8925        assert_eq!(
8926            endpoint,
8927            ::aws_smithy_types::endpoint::Endpoint::builder()
8928                .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com")
8929                .property(
8930                    "authSchemes",
8931                    vec![{
8932                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8933                        out.insert("name".to_string(), "sigv4".to_string().into());
8934                        out.insert("signingName".to_string(), "s3express".to_string().into());
8935                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8936                        out.insert("disableDoubleEncoding".to_string(), true.into());
8937                        out
8938                    }
8939                    .into()]
8940                )
8941                .property("backend", "S3Express".to_string())
8942                .build()
8943        );
8944    }
8945
8946    /// Data Plane sigv4 auth with short AZ with AP
8947    #[test]
8948    fn test_307() {
8949        let params = crate::config::endpoint::Params::builder()
8950            .region("us-west-2".to_string())
8951            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
8952            .use_fips(false)
8953            .use_dual_stack(false)
8954            .accelerate(false)
8955            .disable_s3_express_session_auth(true)
8956            .build()
8957            .expect("invalid params");
8958        let resolver = crate::config::endpoint::DefaultResolver::new();
8959        let endpoint = resolver.resolve_endpoint(&params);
8960        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.us-west-2.amazonaws.com");
8961        assert_eq!(
8962            endpoint,
8963            ::aws_smithy_types::endpoint::Endpoint::builder()
8964                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.us-west-2.amazonaws.com")
8965                .property(
8966                    "authSchemes",
8967                    vec![{
8968                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8969                        out.insert("name".to_string(), "sigv4".to_string().into());
8970                        out.insert("signingName".to_string(), "s3express".to_string().into());
8971                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8972                        out.insert("disableDoubleEncoding".to_string(), true.into());
8973                        out
8974                    }
8975                    .into()]
8976                )
8977                .property("backend", "S3Express".to_string())
8978                .build()
8979        );
8980    }
8981
8982    /// Data Plane sigv4 auth with short zone (13 chars)
8983    #[test]
8984    fn test_308() {
8985        let params = crate::config::endpoint::Params::builder()
8986            .region("us-west-2".to_string())
8987            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
8988            .use_fips(false)
8989            .use_dual_stack(false)
8990            .accelerate(false)
8991            .disable_s3_express_session_auth(true)
8992            .build()
8993            .expect("invalid params");
8994        let resolver = crate::config::endpoint::DefaultResolver::new();
8995        let endpoint = resolver.resolve_endpoint(&params);
8996        let endpoint =
8997            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
8998        assert_eq!(
8999            endpoint,
9000            ::aws_smithy_types::endpoint::Endpoint::builder()
9001                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
9002                .property(
9003                    "authSchemes",
9004                    vec![{
9005                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9006                        out.insert("name".to_string(), "sigv4".to_string().into());
9007                        out.insert("signingName".to_string(), "s3express".to_string().into());
9008                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9009                        out.insert("disableDoubleEncoding".to_string(), true.into());
9010                        out
9011                    }
9012                    .into()]
9013                )
9014                .property("backend", "S3Express".to_string())
9015                .build()
9016        );
9017    }
9018
9019    /// Data Plane sigv4 auth with short zone (13 chars) with AP
9020    #[test]
9021    fn test_309() {
9022        let params = crate::config::endpoint::Params::builder()
9023            .region("us-west-2".to_string())
9024            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
9025            .use_fips(false)
9026            .use_dual_stack(false)
9027            .accelerate(false)
9028            .disable_s3_express_session_auth(true)
9029            .build()
9030            .expect("invalid params");
9031        let resolver = crate::config::endpoint::DefaultResolver::new();
9032        let endpoint = resolver.resolve_endpoint(&params);
9033        let endpoint =
9034            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
9035        assert_eq!(
9036            endpoint,
9037            ::aws_smithy_types::endpoint::Endpoint::builder()
9038                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
9039                .property(
9040                    "authSchemes",
9041                    vec![{
9042                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9043                        out.insert("name".to_string(), "sigv4".to_string().into());
9044                        out.insert("signingName".to_string(), "s3express".to_string().into());
9045                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9046                        out.insert("disableDoubleEncoding".to_string(), true.into());
9047                        out
9048                    }
9049                    .into()]
9050                )
9051                .property("backend", "S3Express".to_string())
9052                .build()
9053        );
9054    }
9055
9056    /// Data Plane sigv4 auth with short AZ fips
9057    #[test]
9058    fn test_310() {
9059        let params = crate::config::endpoint::Params::builder()
9060            .region("us-west-2".to_string())
9061            .bucket("mybucket--usw2-az1--x-s3".to_string())
9062            .use_fips(true)
9063            .use_dual_stack(false)
9064            .accelerate(false)
9065            .disable_s3_express_session_auth(true)
9066            .build()
9067            .expect("invalid params");
9068        let resolver = crate::config::endpoint::DefaultResolver::new();
9069        let endpoint = resolver.resolve_endpoint(&params);
9070        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com");
9071        assert_eq!(
9072            endpoint,
9073            ::aws_smithy_types::endpoint::Endpoint::builder()
9074                .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com")
9075                .property(
9076                    "authSchemes",
9077                    vec![{
9078                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9079                        out.insert("name".to_string(), "sigv4".to_string().into());
9080                        out.insert("signingName".to_string(), "s3express".to_string().into());
9081                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9082                        out.insert("disableDoubleEncoding".to_string(), true.into());
9083                        out
9084                    }
9085                    .into()]
9086                )
9087                .property("backend", "S3Express".to_string())
9088                .build()
9089        );
9090    }
9091
9092    /// Data Plane sigv4 auth with short AZ fips with AP
9093    #[test]
9094    fn test_311() {
9095        let params = crate::config::endpoint::Params::builder()
9096            .region("us-west-2".to_string())
9097            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
9098            .use_fips(true)
9099            .use_dual_stack(false)
9100            .accelerate(false)
9101            .disable_s3_express_session_auth(true)
9102            .build()
9103            .expect("invalid params");
9104        let resolver = crate::config::endpoint::DefaultResolver::new();
9105        let endpoint = resolver.resolve_endpoint(&params);
9106        let endpoint =
9107            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com");
9108        assert_eq!(
9109            endpoint,
9110            ::aws_smithy_types::endpoint::Endpoint::builder()
9111                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com")
9112                .property(
9113                    "authSchemes",
9114                    vec![{
9115                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9116                        out.insert("name".to_string(), "sigv4".to_string().into());
9117                        out.insert("signingName".to_string(), "s3express".to_string().into());
9118                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9119                        out.insert("disableDoubleEncoding".to_string(), true.into());
9120                        out
9121                    }
9122                    .into()]
9123                )
9124                .property("backend", "S3Express".to_string())
9125                .build()
9126        );
9127    }
9128
9129    /// Data Plane sigv4 auth with short zone (13 chars) fips
9130    #[test]
9131    fn test_312() {
9132        let params = crate::config::endpoint::Params::builder()
9133            .region("us-west-2".to_string())
9134            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
9135            .use_fips(true)
9136            .use_dual_stack(false)
9137            .accelerate(false)
9138            .disable_s3_express_session_auth(true)
9139            .build()
9140            .expect("invalid params");
9141        let resolver = crate::config::endpoint::DefaultResolver::new();
9142        let endpoint = resolver.resolve_endpoint(&params);
9143        let endpoint =
9144            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
9145        assert_eq!(
9146            endpoint,
9147            ::aws_smithy_types::endpoint::Endpoint::builder()
9148                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
9149                .property(
9150                    "authSchemes",
9151                    vec![{
9152                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9153                        out.insert("name".to_string(), "sigv4".to_string().into());
9154                        out.insert("signingName".to_string(), "s3express".to_string().into());
9155                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9156                        out.insert("disableDoubleEncoding".to_string(), true.into());
9157                        out
9158                    }
9159                    .into()]
9160                )
9161                .property("backend", "S3Express".to_string())
9162                .build()
9163        );
9164    }
9165
9166    /// Data Plane sigv4 auth with short zone (13 chars) fips with AP
9167    #[test]
9168    fn test_313() {
9169        let params = crate::config::endpoint::Params::builder()
9170            .region("us-west-2".to_string())
9171            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
9172            .use_fips(true)
9173            .use_dual_stack(false)
9174            .accelerate(false)
9175            .disable_s3_express_session_auth(true)
9176            .build()
9177            .expect("invalid params");
9178        let resolver = crate::config::endpoint::DefaultResolver::new();
9179        let endpoint = resolver.resolve_endpoint(&params);
9180        let endpoint = endpoint
9181            .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
9182        assert_eq!(
9183            endpoint,
9184            ::aws_smithy_types::endpoint::Endpoint::builder()
9185                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
9186                .property(
9187                    "authSchemes",
9188                    vec![{
9189                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9190                        out.insert("name".to_string(), "sigv4".to_string().into());
9191                        out.insert("signingName".to_string(), "s3express".to_string().into());
9192                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9193                        out.insert("disableDoubleEncoding".to_string(), true.into());
9194                        out
9195                    }
9196                    .into()]
9197                )
9198                .property("backend", "S3Express".to_string())
9199                .build()
9200        );
9201    }
9202
9203    /// Data Plane sigv4 auth with long AZ
9204    #[test]
9205    fn test_314() {
9206        let params = crate::config::endpoint::Params::builder()
9207            .region("us-west-2".to_string())
9208            .bucket("mybucket--test1-az1--x-s3".to_string())
9209            .use_fips(false)
9210            .use_dual_stack(false)
9211            .accelerate(false)
9212            .use_s3_express_control_endpoint(false)
9213            .disable_s3_express_session_auth(true)
9214            .build()
9215            .expect("invalid params");
9216        let resolver = crate::config::endpoint::DefaultResolver::new();
9217        let endpoint = resolver.resolve_endpoint(&params);
9218        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com");
9219        assert_eq!(
9220            endpoint,
9221            ::aws_smithy_types::endpoint::Endpoint::builder()
9222                .url("https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com")
9223                .property(
9224                    "authSchemes",
9225                    vec![{
9226                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9227                        out.insert("name".to_string(), "sigv4".to_string().into());
9228                        out.insert("signingName".to_string(), "s3express".to_string().into());
9229                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9230                        out.insert("disableDoubleEncoding".to_string(), true.into());
9231                        out
9232                    }
9233                    .into()]
9234                )
9235                .property("backend", "S3Express".to_string())
9236                .build()
9237        );
9238    }
9239
9240    /// Data Plane sigv4 auth with long AZ with AP
9241    #[test]
9242    fn test_315() {
9243        let params = crate::config::endpoint::Params::builder()
9244            .region("us-west-2".to_string())
9245            .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
9246            .use_fips(false)
9247            .use_dual_stack(false)
9248            .accelerate(false)
9249            .use_s3_express_control_endpoint(false)
9250            .disable_s3_express_session_auth(true)
9251            .build()
9252            .expect("invalid params");
9253        let resolver = crate::config::endpoint::DefaultResolver::new();
9254        let endpoint = resolver.resolve_endpoint(&params);
9255        let endpoint =
9256            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com");
9257        assert_eq!(
9258            endpoint,
9259            ::aws_smithy_types::endpoint::Endpoint::builder()
9260                .url("https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com")
9261                .property(
9262                    "authSchemes",
9263                    vec![{
9264                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9265                        out.insert("name".to_string(), "sigv4".to_string().into());
9266                        out.insert("signingName".to_string(), "s3express".to_string().into());
9267                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9268                        out.insert("disableDoubleEncoding".to_string(), true.into());
9269                        out
9270                    }
9271                    .into()]
9272                )
9273                .property("backend", "S3Express".to_string())
9274                .build()
9275        );
9276    }
9277
9278    /// Data Plane sigv4 auth with medium zone(14 chars)
9279    #[test]
9280    fn test_316() {
9281        let params = crate::config::endpoint::Params::builder()
9282            .region("us-west-2".to_string())
9283            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
9284            .use_fips(false)
9285            .use_dual_stack(false)
9286            .accelerate(false)
9287            .use_s3_express_control_endpoint(false)
9288            .disable_s3_express_session_auth(true)
9289            .build()
9290            .expect("invalid params");
9291        let resolver = crate::config::endpoint::DefaultResolver::new();
9292        let endpoint = resolver.resolve_endpoint(&params);
9293        let endpoint =
9294            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
9295        assert_eq!(
9296            endpoint,
9297            ::aws_smithy_types::endpoint::Endpoint::builder()
9298                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
9299                .property(
9300                    "authSchemes",
9301                    vec![{
9302                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9303                        out.insert("name".to_string(), "sigv4".to_string().into());
9304                        out.insert("signingName".to_string(), "s3express".to_string().into());
9305                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9306                        out.insert("disableDoubleEncoding".to_string(), true.into());
9307                        out
9308                    }
9309                    .into()]
9310                )
9311                .property("backend", "S3Express".to_string())
9312                .build()
9313        );
9314    }
9315
9316    /// Data Plane sigv4 auth with medium zone(14 chars) with AP
9317    #[test]
9318    fn test_317() {
9319        let params = crate::config::endpoint::Params::builder()
9320            .region("us-west-2".to_string())
9321            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
9322            .use_fips(false)
9323            .use_dual_stack(false)
9324            .accelerate(false)
9325            .use_s3_express_control_endpoint(false)
9326            .disable_s3_express_session_auth(true)
9327            .build()
9328            .expect("invalid params");
9329        let resolver = crate::config::endpoint::DefaultResolver::new();
9330        let endpoint = resolver.resolve_endpoint(&params);
9331        let endpoint =
9332            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
9333        assert_eq!(
9334            endpoint,
9335            ::aws_smithy_types::endpoint::Endpoint::builder()
9336                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
9337                .property(
9338                    "authSchemes",
9339                    vec![{
9340                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9341                        out.insert("name".to_string(), "sigv4".to_string().into());
9342                        out.insert("signingName".to_string(), "s3express".to_string().into());
9343                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9344                        out.insert("disableDoubleEncoding".to_string(), true.into());
9345                        out
9346                    }
9347                    .into()]
9348                )
9349                .property("backend", "S3Express".to_string())
9350                .build()
9351        );
9352    }
9353
9354    /// Data Plane sigv4 auth with long zone(20 chars)
9355    #[test]
9356    fn test_318() {
9357        let params = crate::config::endpoint::Params::builder()
9358            .region("us-west-2".to_string())
9359            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
9360            .use_fips(false)
9361            .use_dual_stack(false)
9362            .accelerate(false)
9363            .use_s3_express_control_endpoint(false)
9364            .disable_s3_express_session_auth(true)
9365            .build()
9366            .expect("invalid params");
9367        let resolver = crate::config::endpoint::DefaultResolver::new();
9368        let endpoint = resolver.resolve_endpoint(&params);
9369        let endpoint = endpoint
9370            .expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com");
9371        assert_eq!(
9372            endpoint,
9373            ::aws_smithy_types::endpoint::Endpoint::builder()
9374                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
9375                .property(
9376                    "authSchemes",
9377                    vec![{
9378                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9379                        out.insert("name".to_string(), "sigv4".to_string().into());
9380                        out.insert("signingName".to_string(), "s3express".to_string().into());
9381                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9382                        out.insert("disableDoubleEncoding".to_string(), true.into());
9383                        out
9384                    }
9385                    .into()]
9386                )
9387                .property("backend", "S3Express".to_string())
9388                .build()
9389        );
9390    }
9391
9392    /// Data Plane sigv4 auth with long zone(20 chars) with AP
9393    #[test]
9394    fn test_319() {
9395        let params = crate::config::endpoint::Params::builder()
9396            .region("us-west-2".to_string())
9397            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
9398            .use_fips(false)
9399            .use_dual_stack(false)
9400            .accelerate(false)
9401            .use_s3_express_control_endpoint(false)
9402            .disable_s3_express_session_auth(true)
9403            .build()
9404            .expect("invalid params");
9405        let resolver = crate::config::endpoint::DefaultResolver::new();
9406        let endpoint = resolver.resolve_endpoint(&params);
9407        let endpoint = endpoint.expect(
9408            "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com",
9409        );
9410        assert_eq!(
9411            endpoint,
9412            ::aws_smithy_types::endpoint::Endpoint::builder()
9413                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
9414                .property(
9415                    "authSchemes",
9416                    vec![{
9417                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9418                        out.insert("name".to_string(), "sigv4".to_string().into());
9419                        out.insert("signingName".to_string(), "s3express".to_string().into());
9420                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9421                        out.insert("disableDoubleEncoding".to_string(), true.into());
9422                        out
9423                    }
9424                    .into()]
9425                )
9426                .property("backend", "S3Express".to_string())
9427                .build()
9428        );
9429    }
9430
9431    /// Data Plane sigv4 auth with long AZ fips
9432    #[test]
9433    fn test_320() {
9434        let params = crate::config::endpoint::Params::builder()
9435            .region("us-west-2".to_string())
9436            .bucket("mybucket--test1-az1--x-s3".to_string())
9437            .use_fips(true)
9438            .use_dual_stack(false)
9439            .accelerate(false)
9440            .use_s3_express_control_endpoint(false)
9441            .disable_s3_express_session_auth(true)
9442            .build()
9443            .expect("invalid params");
9444        let resolver = crate::config::endpoint::DefaultResolver::new();
9445        let endpoint = resolver.resolve_endpoint(&params);
9446        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
9447        assert_eq!(
9448            endpoint,
9449            ::aws_smithy_types::endpoint::Endpoint::builder()
9450                .url("https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
9451                .property(
9452                    "authSchemes",
9453                    vec![{
9454                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9455                        out.insert("name".to_string(), "sigv4".to_string().into());
9456                        out.insert("signingName".to_string(), "s3express".to_string().into());
9457                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9458                        out.insert("disableDoubleEncoding".to_string(), true.into());
9459                        out
9460                    }
9461                    .into()]
9462                )
9463                .property("backend", "S3Express".to_string())
9464                .build()
9465        );
9466    }
9467
9468    /// Data Plane sigv4 auth with long AZ fips with AP
9469    #[test]
9470    fn test_321() {
9471        let params = crate::config::endpoint::Params::builder()
9472            .region("us-west-2".to_string())
9473            .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
9474            .use_fips(true)
9475            .use_dual_stack(false)
9476            .accelerate(false)
9477            .use_s3_express_control_endpoint(false)
9478            .disable_s3_express_session_auth(true)
9479            .build()
9480            .expect("invalid params");
9481        let resolver = crate::config::endpoint::DefaultResolver::new();
9482        let endpoint = resolver.resolve_endpoint(&params);
9483        let endpoint =
9484            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
9485        assert_eq!(
9486            endpoint,
9487            ::aws_smithy_types::endpoint::Endpoint::builder()
9488                .url("https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
9489                .property(
9490                    "authSchemes",
9491                    vec![{
9492                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9493                        out.insert("name".to_string(), "sigv4".to_string().into());
9494                        out.insert("signingName".to_string(), "s3express".to_string().into());
9495                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9496                        out.insert("disableDoubleEncoding".to_string(), true.into());
9497                        out
9498                    }
9499                    .into()]
9500                )
9501                .property("backend", "S3Express".to_string())
9502                .build()
9503        );
9504    }
9505
9506    /// Data Plane sigv4 auth with medium zone (14 chars) fips
9507    #[test]
9508    fn test_322() {
9509        let params = crate::config::endpoint::Params::builder()
9510            .region("us-west-2".to_string())
9511            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
9512            .use_fips(true)
9513            .use_dual_stack(false)
9514            .accelerate(false)
9515            .use_s3_express_control_endpoint(false)
9516            .disable_s3_express_session_auth(true)
9517            .build()
9518            .expect("invalid params");
9519        let resolver = crate::config::endpoint::DefaultResolver::new();
9520        let endpoint = resolver.resolve_endpoint(&params);
9521        let endpoint =
9522            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
9523        assert_eq!(
9524            endpoint,
9525            ::aws_smithy_types::endpoint::Endpoint::builder()
9526                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
9527                .property(
9528                    "authSchemes",
9529                    vec![{
9530                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9531                        out.insert("name".to_string(), "sigv4".to_string().into());
9532                        out.insert("signingName".to_string(), "s3express".to_string().into());
9533                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9534                        out.insert("disableDoubleEncoding".to_string(), true.into());
9535                        out
9536                    }
9537                    .into()]
9538                )
9539                .property("backend", "S3Express".to_string())
9540                .build()
9541        );
9542    }
9543
9544    /// Data Plane sigv4 auth with medium zone (14 chars) fips with AP
9545    #[test]
9546    fn test_323() {
9547        let params = crate::config::endpoint::Params::builder()
9548            .region("us-west-2".to_string())
9549            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
9550            .use_fips(true)
9551            .use_dual_stack(false)
9552            .accelerate(false)
9553            .use_s3_express_control_endpoint(false)
9554            .disable_s3_express_session_auth(true)
9555            .build()
9556            .expect("invalid params");
9557        let resolver = crate::config::endpoint::DefaultResolver::new();
9558        let endpoint = resolver.resolve_endpoint(&params);
9559        let endpoint = endpoint
9560            .expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
9561        assert_eq!(
9562            endpoint,
9563            ::aws_smithy_types::endpoint::Endpoint::builder()
9564                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
9565                .property(
9566                    "authSchemes",
9567                    vec![{
9568                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9569                        out.insert("name".to_string(), "sigv4".to_string().into());
9570                        out.insert("signingName".to_string(), "s3express".to_string().into());
9571                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9572                        out.insert("disableDoubleEncoding".to_string(), true.into());
9573                        out
9574                    }
9575                    .into()]
9576                )
9577                .property("backend", "S3Express".to_string())
9578                .build()
9579        );
9580    }
9581
9582    /// Data Plane sigv4 auth with long zone (20 chars) fips
9583    #[test]
9584    fn test_324() {
9585        let params = crate::config::endpoint::Params::builder()
9586            .region("us-west-2".to_string())
9587            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
9588            .use_fips(true)
9589            .use_dual_stack(false)
9590            .accelerate(false)
9591            .use_s3_express_control_endpoint(false)
9592            .disable_s3_express_session_auth(true)
9593            .build()
9594            .expect("invalid params");
9595        let resolver = crate::config::endpoint::DefaultResolver::new();
9596        let endpoint = resolver.resolve_endpoint(&params);
9597        let endpoint = endpoint.expect(
9598            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
9599        );
9600        assert_eq!(
9601            endpoint,
9602            ::aws_smithy_types::endpoint::Endpoint::builder()
9603                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
9604                .property(
9605                    "authSchemes",
9606                    vec![{
9607                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9608                        out.insert("name".to_string(), "sigv4".to_string().into());
9609                        out.insert("signingName".to_string(), "s3express".to_string().into());
9610                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9611                        out.insert("disableDoubleEncoding".to_string(), true.into());
9612                        out
9613                    }
9614                    .into()]
9615                )
9616                .property("backend", "S3Express".to_string())
9617                .build()
9618        );
9619    }
9620
9621    /// Data Plane sigv4 auth with long zone (20 chars) fips with AP
9622    #[test]
9623    fn test_325() {
9624        let params = crate::config::endpoint::Params::builder()
9625            .region("us-west-2".to_string())
9626            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
9627            .use_fips(true)
9628            .use_dual_stack(false)
9629            .accelerate(false)
9630            .use_s3_express_control_endpoint(false)
9631            .disable_s3_express_session_auth(true)
9632            .build()
9633            .expect("invalid params");
9634        let resolver = crate::config::endpoint::DefaultResolver::new();
9635        let endpoint = resolver.resolve_endpoint(&params);
9636        let endpoint = endpoint.expect(
9637            "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
9638        );
9639        assert_eq!(
9640            endpoint,
9641            ::aws_smithy_types::endpoint::Endpoint::builder()
9642                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
9643                .property(
9644                    "authSchemes",
9645                    vec![{
9646                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9647                        out.insert("name".to_string(), "sigv4".to_string().into());
9648                        out.insert("signingName".to_string(), "s3express".to_string().into());
9649                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9650                        out.insert("disableDoubleEncoding".to_string(), true.into());
9651                        out
9652                    }
9653                    .into()]
9654                )
9655                .property("backend", "S3Express".to_string())
9656                .build()
9657        );
9658    }
9659
9660    /// Control Plane host override
9661    #[test]
9662    fn test_326() {
9663        let params = crate::config::endpoint::Params::builder()
9664            .region("us-west-2".to_string())
9665            .bucket("mybucket--usw2-az1--x-s3".to_string())
9666            .use_fips(false)
9667            .use_dual_stack(false)
9668            .accelerate(false)
9669            .use_s3_express_control_endpoint(true)
9670            .disable_s3_express_session_auth(true)
9671            .endpoint("https://custom.com".to_string())
9672            .build()
9673            .expect("invalid params");
9674        let resolver = crate::config::endpoint::DefaultResolver::new();
9675        let endpoint = resolver.resolve_endpoint(&params);
9676        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
9677        assert_eq!(
9678            endpoint,
9679            ::aws_smithy_types::endpoint::Endpoint::builder()
9680                .url("https://mybucket--usw2-az1--x-s3.custom.com")
9681                .property(
9682                    "authSchemes",
9683                    vec![{
9684                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9685                        out.insert("name".to_string(), "sigv4".to_string().into());
9686                        out.insert("signingName".to_string(), "s3express".to_string().into());
9687                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9688                        out.insert("disableDoubleEncoding".to_string(), true.into());
9689                        out
9690                    }
9691                    .into()]
9692                )
9693                .property("backend", "S3Express".to_string())
9694                .build()
9695        );
9696    }
9697
9698    /// Control Plane host override with AP
9699    #[test]
9700    fn test_327() {
9701        let params = crate::config::endpoint::Params::builder()
9702            .region("us-west-2".to_string())
9703            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
9704            .use_fips(false)
9705            .use_dual_stack(false)
9706            .accelerate(false)
9707            .use_s3_express_control_endpoint(true)
9708            .disable_s3_express_session_auth(true)
9709            .endpoint("https://custom.com".to_string())
9710            .build()
9711            .expect("invalid params");
9712        let resolver = crate::config::endpoint::DefaultResolver::new();
9713        let endpoint = resolver.resolve_endpoint(&params);
9714        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.custom.com");
9715        assert_eq!(
9716            endpoint,
9717            ::aws_smithy_types::endpoint::Endpoint::builder()
9718                .url("https://myaccesspoint--usw2-az1--xa-s3.custom.com")
9719                .property(
9720                    "authSchemes",
9721                    vec![{
9722                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9723                        out.insert("name".to_string(), "sigv4".to_string().into());
9724                        out.insert("signingName".to_string(), "s3express".to_string().into());
9725                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9726                        out.insert("disableDoubleEncoding".to_string(), true.into());
9727                        out
9728                    }
9729                    .into()]
9730                )
9731                .property("backend", "S3Express".to_string())
9732                .build()
9733        );
9734    }
9735
9736    /// Control Plane host override no bucket
9737    #[test]
9738    fn test_328() {
9739        let params = crate::config::endpoint::Params::builder()
9740            .region("us-west-2".to_string())
9741            .use_fips(false)
9742            .use_dual_stack(false)
9743            .accelerate(false)
9744            .use_s3_express_control_endpoint(true)
9745            .disable_s3_express_session_auth(true)
9746            .endpoint("https://custom.com".to_string())
9747            .build()
9748            .expect("invalid params");
9749        let resolver = crate::config::endpoint::DefaultResolver::new();
9750        let endpoint = resolver.resolve_endpoint(&params);
9751        let endpoint = endpoint.expect("Expected valid endpoint: https://custom.com");
9752        assert_eq!(
9753            endpoint,
9754            ::aws_smithy_types::endpoint::Endpoint::builder()
9755                .url("https://custom.com")
9756                .property(
9757                    "authSchemes",
9758                    vec![{
9759                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9760                        out.insert("name".to_string(), "sigv4".to_string().into());
9761                        out.insert("signingName".to_string(), "s3express".to_string().into());
9762                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9763                        out.insert("disableDoubleEncoding".to_string(), true.into());
9764                        out
9765                    }
9766                    .into()]
9767                )
9768                .property("backend", "S3Express".to_string())
9769                .build()
9770        );
9771    }
9772
9773    /// Data plane host override non virtual session auth
9774    #[test]
9775    fn test_329() {
9776        let params = crate::config::endpoint::Params::builder()
9777            .region("us-west-2".to_string())
9778            .bucket("mybucket--usw2-az1--x-s3".to_string())
9779            .use_fips(false)
9780            .use_dual_stack(false)
9781            .accelerate(false)
9782            .endpoint("https://10.0.0.1".to_string())
9783            .build()
9784            .expect("invalid params");
9785        let resolver = crate::config::endpoint::DefaultResolver::new();
9786        let endpoint = resolver.resolve_endpoint(&params);
9787        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
9788        assert_eq!(
9789            endpoint,
9790            ::aws_smithy_types::endpoint::Endpoint::builder()
9791                .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
9792                .property(
9793                    "authSchemes",
9794                    vec![{
9795                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9796                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
9797                        out.insert("signingName".to_string(), "s3express".to_string().into());
9798                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9799                        out.insert("disableDoubleEncoding".to_string(), true.into());
9800                        out
9801                    }
9802                    .into()]
9803                )
9804                .property("backend", "S3Express".to_string())
9805                .build()
9806        );
9807    }
9808
9809    /// Data plane host override non virtual session auth with AP
9810    #[test]
9811    fn test_330() {
9812        let params = crate::config::endpoint::Params::builder()
9813            .region("us-west-2".to_string())
9814            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
9815            .use_fips(false)
9816            .use_dual_stack(false)
9817            .accelerate(false)
9818            .endpoint("https://10.0.0.1".to_string())
9819            .build()
9820            .expect("invalid params");
9821        let resolver = crate::config::endpoint::DefaultResolver::new();
9822        let endpoint = resolver.resolve_endpoint(&params);
9823        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3");
9824        assert_eq!(
9825            endpoint,
9826            ::aws_smithy_types::endpoint::Endpoint::builder()
9827                .url("https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3")
9828                .property(
9829                    "authSchemes",
9830                    vec![{
9831                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9832                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
9833                        out.insert("signingName".to_string(), "s3express".to_string().into());
9834                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9835                        out.insert("disableDoubleEncoding".to_string(), true.into());
9836                        out
9837                    }
9838                    .into()]
9839                )
9840                .property("backend", "S3Express".to_string())
9841                .build()
9842        );
9843    }
9844
9845    /// Control Plane host override ip
9846    #[test]
9847    fn test_331() {
9848        let params = crate::config::endpoint::Params::builder()
9849            .region("us-west-2".to_string())
9850            .bucket("mybucket--usw2-az1--x-s3".to_string())
9851            .use_fips(false)
9852            .use_dual_stack(false)
9853            .accelerate(false)
9854            .use_s3_express_control_endpoint(true)
9855            .disable_s3_express_session_auth(true)
9856            .endpoint("https://10.0.0.1".to_string())
9857            .build()
9858            .expect("invalid params");
9859        let resolver = crate::config::endpoint::DefaultResolver::new();
9860        let endpoint = resolver.resolve_endpoint(&params);
9861        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
9862        assert_eq!(
9863            endpoint,
9864            ::aws_smithy_types::endpoint::Endpoint::builder()
9865                .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
9866                .property(
9867                    "authSchemes",
9868                    vec![{
9869                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9870                        out.insert("name".to_string(), "sigv4".to_string().into());
9871                        out.insert("signingName".to_string(), "s3express".to_string().into());
9872                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9873                        out.insert("disableDoubleEncoding".to_string(), true.into());
9874                        out
9875                    }
9876                    .into()]
9877                )
9878                .property("backend", "S3Express".to_string())
9879                .build()
9880        );
9881    }
9882
9883    /// Control Plane host override ip with AP
9884    #[test]
9885    fn test_332() {
9886        let params = crate::config::endpoint::Params::builder()
9887            .region("us-west-2".to_string())
9888            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
9889            .use_fips(false)
9890            .use_dual_stack(false)
9891            .accelerate(false)
9892            .use_s3_express_control_endpoint(true)
9893            .disable_s3_express_session_auth(true)
9894            .endpoint("https://10.0.0.1".to_string())
9895            .build()
9896            .expect("invalid params");
9897        let resolver = crate::config::endpoint::DefaultResolver::new();
9898        let endpoint = resolver.resolve_endpoint(&params);
9899        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3");
9900        assert_eq!(
9901            endpoint,
9902            ::aws_smithy_types::endpoint::Endpoint::builder()
9903                .url("https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3")
9904                .property(
9905                    "authSchemes",
9906                    vec![{
9907                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9908                        out.insert("name".to_string(), "sigv4".to_string().into());
9909                        out.insert("signingName".to_string(), "s3express".to_string().into());
9910                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9911                        out.insert("disableDoubleEncoding".to_string(), true.into());
9912                        out
9913                    }
9914                    .into()]
9915                )
9916                .property("backend", "S3Express".to_string())
9917                .build()
9918        );
9919    }
9920
9921    /// Data plane host override
9922    #[test]
9923    fn test_333() {
9924        let params = crate::config::endpoint::Params::builder()
9925            .region("us-west-2".to_string())
9926            .bucket("mybucket--usw2-az1--x-s3".to_string())
9927            .use_fips(false)
9928            .use_dual_stack(false)
9929            .accelerate(false)
9930            .endpoint("https://custom.com".to_string())
9931            .build()
9932            .expect("invalid params");
9933        let resolver = crate::config::endpoint::DefaultResolver::new();
9934        let endpoint = resolver.resolve_endpoint(&params);
9935        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
9936        assert_eq!(
9937            endpoint,
9938            ::aws_smithy_types::endpoint::Endpoint::builder()
9939                .url("https://mybucket--usw2-az1--x-s3.custom.com")
9940                .property(
9941                    "authSchemes",
9942                    vec![{
9943                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9944                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
9945                        out.insert("signingName".to_string(), "s3express".to_string().into());
9946                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9947                        out.insert("disableDoubleEncoding".to_string(), true.into());
9948                        out
9949                    }
9950                    .into()]
9951                )
9952                .property("backend", "S3Express".to_string())
9953                .build()
9954        );
9955    }
9956
9957    /// Data plane host override with AP
9958    #[test]
9959    fn test_334() {
9960        let params = crate::config::endpoint::Params::builder()
9961            .region("us-west-2".to_string())
9962            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
9963            .use_fips(false)
9964            .use_dual_stack(false)
9965            .accelerate(false)
9966            .endpoint("https://custom.com".to_string())
9967            .build()
9968            .expect("invalid params");
9969        let resolver = crate::config::endpoint::DefaultResolver::new();
9970        let endpoint = resolver.resolve_endpoint(&params);
9971        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.custom.com");
9972        assert_eq!(
9973            endpoint,
9974            ::aws_smithy_types::endpoint::Endpoint::builder()
9975                .url("https://myaccesspoint--usw2-az1--xa-s3.custom.com")
9976                .property(
9977                    "authSchemes",
9978                    vec![{
9979                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
9980                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
9981                        out.insert("signingName".to_string(), "s3express".to_string().into());
9982                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
9983                        out.insert("disableDoubleEncoding".to_string(), true.into());
9984                        out
9985                    }
9986                    .into()]
9987                )
9988                .property("backend", "S3Express".to_string())
9989                .build()
9990        );
9991    }
9992
9993    /// bad format error
9994    #[test]
9995    fn test_335() {
9996        let params = crate::config::endpoint::Params::builder()
9997            .region("us-east-1".to_string())
9998            .bucket("mybucket--usaz1--x-s3".to_string())
9999            .use_fips(false)
10000            .use_dual_stack(false)
10001            .accelerate(false)
10002            .use_s3_express_control_endpoint(false)
10003            .build()
10004            .expect("invalid params");
10005        let resolver = crate::config::endpoint::DefaultResolver::new();
10006        let endpoint = resolver.resolve_endpoint(&params);
10007        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad format error]");
10008        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
10009    }
10010
10011    /// bad AP format error
10012    #[test]
10013    fn test_336() {
10014        let params = crate::config::endpoint::Params::builder()
10015            .region("us-east-1".to_string())
10016            .bucket("myaccesspoint--usaz1--xa-s3".to_string())
10017            .use_fips(false)
10018            .use_dual_stack(false)
10019            .accelerate(false)
10020            .use_s3_express_control_endpoint(false)
10021            .build()
10022            .expect("invalid params");
10023        let resolver = crate::config::endpoint::DefaultResolver::new();
10024        let endpoint = resolver.resolve_endpoint(&params);
10025        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad AP format error]");
10026        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
10027    }
10028
10029    /// bad format error no session auth
10030    #[test]
10031    fn test_337() {
10032        let params = crate::config::endpoint::Params::builder()
10033            .region("us-east-1".to_string())
10034            .bucket("mybucket--usaz1--x-s3".to_string())
10035            .use_fips(false)
10036            .use_dual_stack(false)
10037            .accelerate(false)
10038            .use_s3_express_control_endpoint(false)
10039            .disable_s3_express_session_auth(true)
10040            .build()
10041            .expect("invalid params");
10042        let resolver = crate::config::endpoint::DefaultResolver::new();
10043        let endpoint = resolver.resolve_endpoint(&params);
10044        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad format error no session auth]");
10045        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
10046    }
10047
10048    /// bad AP format error no session auth
10049    #[test]
10050    fn test_338() {
10051        let params = crate::config::endpoint::Params::builder()
10052            .region("us-east-1".to_string())
10053            .bucket("myaccesspoint--usaz1--xa-s3".to_string())
10054            .use_fips(false)
10055            .use_dual_stack(false)
10056            .accelerate(false)
10057            .use_s3_express_control_endpoint(false)
10058            .disable_s3_express_session_auth(true)
10059            .build()
10060            .expect("invalid params");
10061        let resolver = crate::config::endpoint::DefaultResolver::new();
10062        let endpoint = resolver.resolve_endpoint(&params);
10063        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad AP format error no session auth]");
10064        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
10065    }
10066
10067    /// accelerate error
10068    #[test]
10069    fn test_339() {
10070        let params = crate::config::endpoint::Params::builder()
10071            .region("us-east-1".to_string())
10072            .bucket("mybucket--test-ab1--x-s3".to_string())
10073            .use_fips(false)
10074            .use_dual_stack(false)
10075            .accelerate(true)
10076            .use_s3_express_control_endpoint(false)
10077            .build()
10078            .expect("invalid params");
10079        let resolver = crate::config::endpoint::DefaultResolver::new();
10080        let endpoint = resolver.resolve_endpoint(&params);
10081        let error = endpoint.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error]");
10082        assert_eq!(format!("{}", error), "S3Express does not support S3 Accelerate.")
10083    }
10084
10085    /// accelerate error with AP
10086    #[test]
10087    fn test_340() {
10088        let params = crate::config::endpoint::Params::builder()
10089            .region("us-east-1".to_string())
10090            .bucket("myaccesspoint--test-ab1--xa-s3".to_string())
10091            .use_fips(false)
10092            .use_dual_stack(false)
10093            .accelerate(true)
10094            .use_s3_express_control_endpoint(false)
10095            .build()
10096            .expect("invalid params");
10097        let resolver = crate::config::endpoint::DefaultResolver::new();
10098        let endpoint = resolver.resolve_endpoint(&params);
10099        let error = endpoint.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error with AP]");
10100        assert_eq!(format!("{}", error), "S3Express does not support S3 Accelerate.")
10101    }
10102
10103    /// Data plane bucket format error
10104    #[test]
10105    fn test_341() {
10106        let params = crate::config::endpoint::Params::builder()
10107            .region("us-east-1".to_string())
10108            .bucket("my.bucket--test-ab1--x-s3".to_string())
10109            .use_fips(false)
10110            .use_dual_stack(false)
10111            .accelerate(false)
10112            .use_s3_express_control_endpoint(false)
10113            .build()
10114            .expect("invalid params");
10115        let resolver = crate::config::endpoint::DefaultResolver::new();
10116        let endpoint = resolver.resolve_endpoint(&params);
10117        let error =
10118            endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane bucket format error]");
10119        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
10120    }
10121
10122    /// Data plane AP format error
10123    #[test]
10124    fn test_342() {
10125        let params = crate::config::endpoint::Params::builder()
10126            .region("us-east-1".to_string())
10127            .bucket("my.myaccesspoint--test-ab1--xa-s3".to_string())
10128            .use_fips(false)
10129            .use_dual_stack(false)
10130            .accelerate(false)
10131            .use_s3_express_control_endpoint(false)
10132            .build()
10133            .expect("invalid params");
10134        let resolver = crate::config::endpoint::DefaultResolver::new();
10135        let endpoint = resolver.resolve_endpoint(&params);
10136        let error = endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane AP format error]");
10137        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
10138    }
10139
10140    /// host override data plane bucket error session auth
10141    #[test]
10142    fn test_343() {
10143        let params = crate::config::endpoint::Params::builder()
10144            .region("us-west-2".to_string())
10145            .bucket("my.bucket--usw2-az1--x-s3".to_string())
10146            .use_fips(false)
10147            .use_dual_stack(false)
10148            .accelerate(false)
10149            .endpoint("https://custom.com".to_string())
10150            .build()
10151            .expect("invalid params");
10152        let resolver = crate::config::endpoint::DefaultResolver::new();
10153        let endpoint = resolver.resolve_endpoint(&params);
10154        let error = endpoint.expect_err(
10155            "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error session auth]",
10156        );
10157        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
10158    }
10159
10160    /// host override data plane AP error session auth
10161    #[test]
10162    fn test_344() {
10163        let params = crate::config::endpoint::Params::builder()
10164            .region("us-west-2".to_string())
10165            .bucket("my.myaccesspoint--usw2-az1--xa-s3".to_string())
10166            .use_fips(false)
10167            .use_dual_stack(false)
10168            .accelerate(false)
10169            .endpoint("https://custom.com".to_string())
10170            .build()
10171            .expect("invalid params");
10172        let resolver = crate::config::endpoint::DefaultResolver::new();
10173        let endpoint = resolver.resolve_endpoint(&params);
10174        let error = endpoint.expect_err(
10175            "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane AP error session auth]",
10176        );
10177        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
10178    }
10179
10180    /// host override data plane bucket error
10181    #[test]
10182    fn test_345() {
10183        let params = crate::config::endpoint::Params::builder()
10184            .region("us-west-2".to_string())
10185            .bucket("my.bucket--usw2-az1--x-s3".to_string())
10186            .use_fips(false)
10187            .use_dual_stack(false)
10188            .accelerate(false)
10189            .endpoint("https://custom.com".to_string())
10190            .disable_s3_express_session_auth(true)
10191            .build()
10192            .expect("invalid params");
10193        let resolver = crate::config::endpoint::DefaultResolver::new();
10194        let endpoint = resolver.resolve_endpoint(&params);
10195        let error = endpoint
10196            .expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error]");
10197        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
10198    }
10199
10200    /// host override data plane AP error
10201    #[test]
10202    fn test_346() {
10203        let params = crate::config::endpoint::Params::builder()
10204            .region("us-west-2".to_string())
10205            .bucket("my.myaccesspoint--usw2-az1--xa-s3".to_string())
10206            .use_fips(false)
10207            .use_dual_stack(false)
10208            .accelerate(false)
10209            .endpoint("https://custom.com".to_string())
10210            .disable_s3_express_session_auth(true)
10211            .build()
10212            .expect("invalid params");
10213        let resolver = crate::config::endpoint::DefaultResolver::new();
10214        let endpoint = resolver.resolve_endpoint(&params);
10215        let error =
10216            endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane AP error]");
10217        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
10218    }
10219
10220    /// Control plane without bucket and dualstack
10221    #[test]
10222    fn test_347() {
10223        let params = crate::config::endpoint::Params::builder()
10224            .region("us-east-1".to_string())
10225            .use_fips(false)
10226            .use_dual_stack(true)
10227            .accelerate(false)
10228            .use_s3_express_control_endpoint(true)
10229            .disable_s3_express_session_auth(false)
10230            .build()
10231            .expect("invalid params");
10232        let resolver = crate::config::endpoint::DefaultResolver::new();
10233        let endpoint = resolver.resolve_endpoint(&params);
10234        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.dualstack.us-east-1.amazonaws.com");
10235        assert_eq!(
10236            endpoint,
10237            ::aws_smithy_types::endpoint::Endpoint::builder()
10238                .url("https://s3express-control.dualstack.us-east-1.amazonaws.com")
10239                .property(
10240                    "authSchemes",
10241                    vec![{
10242                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10243                        out.insert("name".to_string(), "sigv4".to_string().into());
10244                        out.insert("signingName".to_string(), "s3express".to_string().into());
10245                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
10246                        out.insert("disableDoubleEncoding".to_string(), true.into());
10247                        out
10248                    }
10249                    .into()]
10250                )
10251                .property("backend", "S3Express".to_string())
10252                .build()
10253        );
10254    }
10255
10256    /// Control plane without bucket, fips and dualstack
10257    #[test]
10258    fn test_348() {
10259        let params = crate::config::endpoint::Params::builder()
10260            .region("us-east-1".to_string())
10261            .use_fips(true)
10262            .use_dual_stack(true)
10263            .accelerate(false)
10264            .use_s3_express_control_endpoint(true)
10265            .disable_s3_express_session_auth(false)
10266            .build()
10267            .expect("invalid params");
10268        let resolver = crate::config::endpoint::DefaultResolver::new();
10269        let endpoint = resolver.resolve_endpoint(&params);
10270        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.dualstack.us-east-1.amazonaws.com");
10271        assert_eq!(
10272            endpoint,
10273            ::aws_smithy_types::endpoint::Endpoint::builder()
10274                .url("https://s3express-control-fips.dualstack.us-east-1.amazonaws.com")
10275                .property(
10276                    "authSchemes",
10277                    vec![{
10278                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10279                        out.insert("name".to_string(), "sigv4".to_string().into());
10280                        out.insert("signingName".to_string(), "s3express".to_string().into());
10281                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
10282                        out.insert("disableDoubleEncoding".to_string(), true.into());
10283                        out
10284                    }
10285                    .into()]
10286                )
10287                .property("backend", "S3Express".to_string())
10288                .build()
10289        );
10290    }
10291
10292    /// Data Plane with short AZ and dualstack
10293    #[test]
10294    fn test_349() {
10295        let params = crate::config::endpoint::Params::builder()
10296            .region("us-west-2".to_string())
10297            .bucket("mybucket--usw2-az1--x-s3".to_string())
10298            .use_fips(false)
10299            .use_dual_stack(true)
10300            .accelerate(false)
10301            .use_s3_express_control_endpoint(false)
10302            .build()
10303            .expect("invalid params");
10304        let resolver = crate::config::endpoint::DefaultResolver::new();
10305        let endpoint = resolver.resolve_endpoint(&params);
10306        let endpoint =
10307            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
10308        assert_eq!(
10309            endpoint,
10310            ::aws_smithy_types::endpoint::Endpoint::builder()
10311                .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
10312                .property(
10313                    "authSchemes",
10314                    vec![{
10315                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10316                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
10317                        out.insert("signingName".to_string(), "s3express".to_string().into());
10318                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10319                        out.insert("disableDoubleEncoding".to_string(), true.into());
10320                        out
10321                    }
10322                    .into()]
10323                )
10324                .property("backend", "S3Express".to_string())
10325                .build()
10326        );
10327    }
10328
10329    /// Data Plane with short AZ and FIPS with dualstack
10330    #[test]
10331    fn test_350() {
10332        let params = crate::config::endpoint::Params::builder()
10333            .region("us-west-2".to_string())
10334            .bucket("mybucket--usw2-az1--x-s3".to_string())
10335            .use_fips(true)
10336            .use_dual_stack(true)
10337            .accelerate(false)
10338            .use_s3_express_control_endpoint(false)
10339            .build()
10340            .expect("invalid params");
10341        let resolver = crate::config::endpoint::DefaultResolver::new();
10342        let endpoint = resolver.resolve_endpoint(&params);
10343        let endpoint =
10344            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
10345        assert_eq!(
10346            endpoint,
10347            ::aws_smithy_types::endpoint::Endpoint::builder()
10348                .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
10349                .property(
10350                    "authSchemes",
10351                    vec![{
10352                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10353                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
10354                        out.insert("signingName".to_string(), "s3express".to_string().into());
10355                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10356                        out.insert("disableDoubleEncoding".to_string(), true.into());
10357                        out
10358                    }
10359                    .into()]
10360                )
10361                .property("backend", "S3Express".to_string())
10362                .build()
10363        );
10364    }
10365
10366    /// Data Plane sigv4 auth with short AZ and dualstack
10367    #[test]
10368    fn test_351() {
10369        let params = crate::config::endpoint::Params::builder()
10370            .region("us-west-2".to_string())
10371            .bucket("mybucket--usw2-az1--x-s3".to_string())
10372            .use_fips(false)
10373            .use_dual_stack(true)
10374            .accelerate(false)
10375            .disable_s3_express_session_auth(true)
10376            .build()
10377            .expect("invalid params");
10378        let resolver = crate::config::endpoint::DefaultResolver::new();
10379        let endpoint = resolver.resolve_endpoint(&params);
10380        let endpoint =
10381            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
10382        assert_eq!(
10383            endpoint,
10384            ::aws_smithy_types::endpoint::Endpoint::builder()
10385                .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
10386                .property(
10387                    "authSchemes",
10388                    vec![{
10389                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10390                        out.insert("name".to_string(), "sigv4".to_string().into());
10391                        out.insert("signingName".to_string(), "s3express".to_string().into());
10392                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10393                        out.insert("disableDoubleEncoding".to_string(), true.into());
10394                        out
10395                    }
10396                    .into()]
10397                )
10398                .property("backend", "S3Express".to_string())
10399                .build()
10400        );
10401    }
10402
10403    /// Data Plane sigv4 auth with short AZ and FIPS with dualstack
10404    #[test]
10405    fn test_352() {
10406        let params = crate::config::endpoint::Params::builder()
10407            .region("us-west-2".to_string())
10408            .bucket("mybucket--usw2-az1--x-s3".to_string())
10409            .use_fips(true)
10410            .use_dual_stack(true)
10411            .accelerate(false)
10412            .disable_s3_express_session_auth(true)
10413            .build()
10414            .expect("invalid params");
10415        let resolver = crate::config::endpoint::DefaultResolver::new();
10416        let endpoint = resolver.resolve_endpoint(&params);
10417        let endpoint =
10418            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
10419        assert_eq!(
10420            endpoint,
10421            ::aws_smithy_types::endpoint::Endpoint::builder()
10422                .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
10423                .property(
10424                    "authSchemes",
10425                    vec![{
10426                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10427                        out.insert("name".to_string(), "sigv4".to_string().into());
10428                        out.insert("signingName".to_string(), "s3express".to_string().into());
10429                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10430                        out.insert("disableDoubleEncoding".to_string(), true.into());
10431                        out
10432                    }
10433                    .into()]
10434                )
10435                .property("backend", "S3Express".to_string())
10436                .build()
10437        );
10438    }
10439
10440    /// Data Plane with zone and dualstack
10441    #[test]
10442    fn test_353() {
10443        let params = crate::config::endpoint::Params::builder()
10444            .region("us-west-2".to_string())
10445            .bucket("mybucket--usw2-az12--x-s3".to_string())
10446            .use_fips(false)
10447            .use_dual_stack(true)
10448            .accelerate(false)
10449            .use_s3_express_control_endpoint(false)
10450            .build()
10451            .expect("invalid params");
10452        let resolver = crate::config::endpoint::DefaultResolver::new();
10453        let endpoint = resolver.resolve_endpoint(&params);
10454        let endpoint =
10455            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
10456        assert_eq!(
10457            endpoint,
10458            ::aws_smithy_types::endpoint::Endpoint::builder()
10459                .url("https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
10460                .property(
10461                    "authSchemes",
10462                    vec![{
10463                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10464                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
10465                        out.insert("signingName".to_string(), "s3express".to_string().into());
10466                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10467                        out.insert("disableDoubleEncoding".to_string(), true.into());
10468                        out
10469                    }
10470                    .into()]
10471                )
10472                .property("backend", "S3Express".to_string())
10473                .build()
10474        );
10475    }
10476
10477    /// Data Plane with zone and FIPS with dualstack
10478    #[test]
10479    fn test_354() {
10480        let params = crate::config::endpoint::Params::builder()
10481            .region("us-west-2".to_string())
10482            .bucket("mybucket--usw2-az12--x-s3".to_string())
10483            .use_fips(true)
10484            .use_dual_stack(true)
10485            .accelerate(false)
10486            .use_s3_express_control_endpoint(false)
10487            .build()
10488            .expect("invalid params");
10489        let resolver = crate::config::endpoint::DefaultResolver::new();
10490        let endpoint = resolver.resolve_endpoint(&params);
10491        let endpoint =
10492            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
10493        assert_eq!(
10494            endpoint,
10495            ::aws_smithy_types::endpoint::Endpoint::builder()
10496                .url("https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
10497                .property(
10498                    "authSchemes",
10499                    vec![{
10500                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10501                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
10502                        out.insert("signingName".to_string(), "s3express".to_string().into());
10503                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10504                        out.insert("disableDoubleEncoding".to_string(), true.into());
10505                        out
10506                    }
10507                    .into()]
10508                )
10509                .property("backend", "S3Express".to_string())
10510                .build()
10511        );
10512    }
10513
10514    /// Data Plane sigv4 auth with zone and dualstack
10515    #[test]
10516    fn test_355() {
10517        let params = crate::config::endpoint::Params::builder()
10518            .region("us-west-2".to_string())
10519            .bucket("mybucket--usw2-az12--x-s3".to_string())
10520            .use_fips(false)
10521            .use_dual_stack(true)
10522            .accelerate(false)
10523            .disable_s3_express_session_auth(true)
10524            .build()
10525            .expect("invalid params");
10526        let resolver = crate::config::endpoint::DefaultResolver::new();
10527        let endpoint = resolver.resolve_endpoint(&params);
10528        let endpoint =
10529            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
10530        assert_eq!(
10531            endpoint,
10532            ::aws_smithy_types::endpoint::Endpoint::builder()
10533                .url("https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
10534                .property(
10535                    "authSchemes",
10536                    vec![{
10537                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10538                        out.insert("name".to_string(), "sigv4".to_string().into());
10539                        out.insert("signingName".to_string(), "s3express".to_string().into());
10540                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10541                        out.insert("disableDoubleEncoding".to_string(), true.into());
10542                        out
10543                    }
10544                    .into()]
10545                )
10546                .property("backend", "S3Express".to_string())
10547                .build()
10548        );
10549    }
10550
10551    /// Data Plane sigv4 auth with 9-char zone and FIPS with dualstack
10552    #[test]
10553    fn test_356() {
10554        let params = crate::config::endpoint::Params::builder()
10555            .region("us-west-2".to_string())
10556            .bucket("mybucket--usw2-az12--x-s3".to_string())
10557            .use_fips(true)
10558            .use_dual_stack(true)
10559            .accelerate(false)
10560            .disable_s3_express_session_auth(true)
10561            .build()
10562            .expect("invalid params");
10563        let resolver = crate::config::endpoint::DefaultResolver::new();
10564        let endpoint = resolver.resolve_endpoint(&params);
10565        let endpoint =
10566            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
10567        assert_eq!(
10568            endpoint,
10569            ::aws_smithy_types::endpoint::Endpoint::builder()
10570                .url("https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
10571                .property(
10572                    "authSchemes",
10573                    vec![{
10574                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10575                        out.insert("name".to_string(), "sigv4".to_string().into());
10576                        out.insert("signingName".to_string(), "s3express".to_string().into());
10577                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10578                        out.insert("disableDoubleEncoding".to_string(), true.into());
10579                        out
10580                    }
10581                    .into()]
10582                )
10583                .property("backend", "S3Express".to_string())
10584                .build()
10585        );
10586    }
10587
10588    /// Data Plane with 13-char zone and dualstack
10589    #[test]
10590    fn test_357() {
10591        let params = crate::config::endpoint::Params::builder()
10592            .region("us-west-2".to_string())
10593            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
10594            .use_fips(false)
10595            .use_dual_stack(true)
10596            .accelerate(false)
10597            .use_s3_express_control_endpoint(false)
10598            .build()
10599            .expect("invalid params");
10600        let resolver = crate::config::endpoint::DefaultResolver::new();
10601        let endpoint = resolver.resolve_endpoint(&params);
10602        let endpoint = endpoint
10603            .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
10604        assert_eq!(
10605            endpoint,
10606            ::aws_smithy_types::endpoint::Endpoint::builder()
10607                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
10608                .property(
10609                    "authSchemes",
10610                    vec![{
10611                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10612                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
10613                        out.insert("signingName".to_string(), "s3express".to_string().into());
10614                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10615                        out.insert("disableDoubleEncoding".to_string(), true.into());
10616                        out
10617                    }
10618                    .into()]
10619                )
10620                .property("backend", "S3Express".to_string())
10621                .build()
10622        );
10623    }
10624
10625    /// Data Plane with 13-char zone and FIPS with dualstack
10626    #[test]
10627    fn test_358() {
10628        let params = crate::config::endpoint::Params::builder()
10629            .region("us-west-2".to_string())
10630            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
10631            .use_fips(true)
10632            .use_dual_stack(true)
10633            .accelerate(false)
10634            .use_s3_express_control_endpoint(false)
10635            .build()
10636            .expect("invalid params");
10637        let resolver = crate::config::endpoint::DefaultResolver::new();
10638        let endpoint = resolver.resolve_endpoint(&params);
10639        let endpoint = endpoint
10640            .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
10641        assert_eq!(
10642            endpoint,
10643            ::aws_smithy_types::endpoint::Endpoint::builder()
10644                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
10645                .property(
10646                    "authSchemes",
10647                    vec![{
10648                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10649                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
10650                        out.insert("signingName".to_string(), "s3express".to_string().into());
10651                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10652                        out.insert("disableDoubleEncoding".to_string(), true.into());
10653                        out
10654                    }
10655                    .into()]
10656                )
10657                .property("backend", "S3Express".to_string())
10658                .build()
10659        );
10660    }
10661
10662    /// Data Plane sigv4 auth with 13-char zone and dualstack
10663    #[test]
10664    fn test_359() {
10665        let params = crate::config::endpoint::Params::builder()
10666            .region("us-west-2".to_string())
10667            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
10668            .use_fips(false)
10669            .use_dual_stack(true)
10670            .accelerate(false)
10671            .disable_s3_express_session_auth(true)
10672            .build()
10673            .expect("invalid params");
10674        let resolver = crate::config::endpoint::DefaultResolver::new();
10675        let endpoint = resolver.resolve_endpoint(&params);
10676        let endpoint = endpoint
10677            .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
10678        assert_eq!(
10679            endpoint,
10680            ::aws_smithy_types::endpoint::Endpoint::builder()
10681                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
10682                .property(
10683                    "authSchemes",
10684                    vec![{
10685                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10686                        out.insert("name".to_string(), "sigv4".to_string().into());
10687                        out.insert("signingName".to_string(), "s3express".to_string().into());
10688                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10689                        out.insert("disableDoubleEncoding".to_string(), true.into());
10690                        out
10691                    }
10692                    .into()]
10693                )
10694                .property("backend", "S3Express".to_string())
10695                .build()
10696        );
10697    }
10698
10699    /// Data Plane sigv4 auth with 13-char zone and FIPS with dualstack
10700    #[test]
10701    fn test_360() {
10702        let params = crate::config::endpoint::Params::builder()
10703            .region("us-west-2".to_string())
10704            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
10705            .use_fips(true)
10706            .use_dual_stack(true)
10707            .accelerate(false)
10708            .disable_s3_express_session_auth(true)
10709            .build()
10710            .expect("invalid params");
10711        let resolver = crate::config::endpoint::DefaultResolver::new();
10712        let endpoint = resolver.resolve_endpoint(&params);
10713        let endpoint = endpoint
10714            .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
10715        assert_eq!(
10716            endpoint,
10717            ::aws_smithy_types::endpoint::Endpoint::builder()
10718                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
10719                .property(
10720                    "authSchemes",
10721                    vec![{
10722                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10723                        out.insert("name".to_string(), "sigv4".to_string().into());
10724                        out.insert("signingName".to_string(), "s3express".to_string().into());
10725                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10726                        out.insert("disableDoubleEncoding".to_string(), true.into());
10727                        out
10728                    }
10729                    .into()]
10730                )
10731                .property("backend", "S3Express".to_string())
10732                .build()
10733        );
10734    }
10735
10736    /// Data Plane with 14-char zone and dualstack
10737    #[test]
10738    fn test_361() {
10739        let params = crate::config::endpoint::Params::builder()
10740            .region("us-west-2".to_string())
10741            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
10742            .use_fips(false)
10743            .use_dual_stack(true)
10744            .accelerate(false)
10745            .use_s3_express_control_endpoint(false)
10746            .build()
10747            .expect("invalid params");
10748        let resolver = crate::config::endpoint::DefaultResolver::new();
10749        let endpoint = resolver.resolve_endpoint(&params);
10750        let endpoint = endpoint
10751            .expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com");
10752        assert_eq!(
10753            endpoint,
10754            ::aws_smithy_types::endpoint::Endpoint::builder()
10755                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10756                .property(
10757                    "authSchemes",
10758                    vec![{
10759                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10760                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
10761                        out.insert("signingName".to_string(), "s3express".to_string().into());
10762                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10763                        out.insert("disableDoubleEncoding".to_string(), true.into());
10764                        out
10765                    }
10766                    .into()]
10767                )
10768                .property("backend", "S3Express".to_string())
10769                .build()
10770        );
10771    }
10772
10773    /// Data Plane with 14-char zone and FIPS with dualstack
10774    #[test]
10775    fn test_362() {
10776        let params = crate::config::endpoint::Params::builder()
10777            .region("us-west-2".to_string())
10778            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
10779            .use_fips(true)
10780            .use_dual_stack(true)
10781            .accelerate(false)
10782            .use_s3_express_control_endpoint(false)
10783            .build()
10784            .expect("invalid params");
10785        let resolver = crate::config::endpoint::DefaultResolver::new();
10786        let endpoint = resolver.resolve_endpoint(&params);
10787        let endpoint = endpoint.expect(
10788            "Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
10789        );
10790        assert_eq!(
10791            endpoint,
10792            ::aws_smithy_types::endpoint::Endpoint::builder()
10793                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10794                .property(
10795                    "authSchemes",
10796                    vec![{
10797                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10798                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
10799                        out.insert("signingName".to_string(), "s3express".to_string().into());
10800                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10801                        out.insert("disableDoubleEncoding".to_string(), true.into());
10802                        out
10803                    }
10804                    .into()]
10805                )
10806                .property("backend", "S3Express".to_string())
10807                .build()
10808        );
10809    }
10810
10811    /// Data Plane sigv4 auth with 14-char zone and dualstack
10812    #[test]
10813    fn test_363() {
10814        let params = crate::config::endpoint::Params::builder()
10815            .region("us-west-2".to_string())
10816            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
10817            .use_fips(false)
10818            .use_dual_stack(true)
10819            .accelerate(false)
10820            .disable_s3_express_session_auth(true)
10821            .build()
10822            .expect("invalid params");
10823        let resolver = crate::config::endpoint::DefaultResolver::new();
10824        let endpoint = resolver.resolve_endpoint(&params);
10825        let endpoint = endpoint
10826            .expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com");
10827        assert_eq!(
10828            endpoint,
10829            ::aws_smithy_types::endpoint::Endpoint::builder()
10830                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10831                .property(
10832                    "authSchemes",
10833                    vec![{
10834                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10835                        out.insert("name".to_string(), "sigv4".to_string().into());
10836                        out.insert("signingName".to_string(), "s3express".to_string().into());
10837                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10838                        out.insert("disableDoubleEncoding".to_string(), true.into());
10839                        out
10840                    }
10841                    .into()]
10842                )
10843                .property("backend", "S3Express".to_string())
10844                .build()
10845        );
10846    }
10847
10848    /// Data Plane sigv4 auth with 14-char zone and FIPS with dualstack
10849    #[test]
10850    fn test_364() {
10851        let params = crate::config::endpoint::Params::builder()
10852            .region("us-west-2".to_string())
10853            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
10854            .use_fips(true)
10855            .use_dual_stack(true)
10856            .accelerate(false)
10857            .disable_s3_express_session_auth(true)
10858            .build()
10859            .expect("invalid params");
10860        let resolver = crate::config::endpoint::DefaultResolver::new();
10861        let endpoint = resolver.resolve_endpoint(&params);
10862        let endpoint = endpoint.expect(
10863            "Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
10864        );
10865        assert_eq!(
10866            endpoint,
10867            ::aws_smithy_types::endpoint::Endpoint::builder()
10868                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10869                .property(
10870                    "authSchemes",
10871                    vec![{
10872                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10873                        out.insert("name".to_string(), "sigv4".to_string().into());
10874                        out.insert("signingName".to_string(), "s3express".to_string().into());
10875                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10876                        out.insert("disableDoubleEncoding".to_string(), true.into());
10877                        out
10878                    }
10879                    .into()]
10880                )
10881                .property("backend", "S3Express".to_string())
10882                .build()
10883        );
10884    }
10885
10886    /// Data Plane with long zone (20 cha) and dualstack
10887    #[test]
10888    fn test_365() {
10889        let params = crate::config::endpoint::Params::builder()
10890            .region("us-west-2".to_string())
10891            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
10892            .use_fips(false)
10893            .use_dual_stack(true)
10894            .accelerate(false)
10895            .use_s3_express_control_endpoint(false)
10896            .build()
10897            .expect("invalid params");
10898        let resolver = crate::config::endpoint::DefaultResolver::new();
10899        let endpoint = resolver.resolve_endpoint(&params);
10900        let endpoint = endpoint.expect(
10901            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com",
10902        );
10903        assert_eq!(
10904            endpoint,
10905            ::aws_smithy_types::endpoint::Endpoint::builder()
10906                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10907                .property(
10908                    "authSchemes",
10909                    vec![{
10910                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10911                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
10912                        out.insert("signingName".to_string(), "s3express".to_string().into());
10913                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10914                        out.insert("disableDoubleEncoding".to_string(), true.into());
10915                        out
10916                    }
10917                    .into()]
10918                )
10919                .property("backend", "S3Express".to_string())
10920                .build()
10921        );
10922    }
10923
10924    /// Data Plane with long zone (20 char) and FIPS with dualstack
10925    #[test]
10926    fn test_366() {
10927        let params = crate::config::endpoint::Params::builder()
10928            .region("us-west-2".to_string())
10929            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
10930            .use_fips(true)
10931            .use_dual_stack(true)
10932            .accelerate(false)
10933            .use_s3_express_control_endpoint(false)
10934            .build()
10935            .expect("invalid params");
10936        let resolver = crate::config::endpoint::DefaultResolver::new();
10937        let endpoint = resolver.resolve_endpoint(&params);
10938        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
10939        assert_eq!(
10940            endpoint,
10941            ::aws_smithy_types::endpoint::Endpoint::builder()
10942                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10943                .property(
10944                    "authSchemes",
10945                    vec![{
10946                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10947                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
10948                        out.insert("signingName".to_string(), "s3express".to_string().into());
10949                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10950                        out.insert("disableDoubleEncoding".to_string(), true.into());
10951                        out
10952                    }
10953                    .into()]
10954                )
10955                .property("backend", "S3Express".to_string())
10956                .build()
10957        );
10958    }
10959
10960    /// Data Plane sigv4 auth with long zone (20 char) and dualstack
10961    #[test]
10962    fn test_367() {
10963        let params = crate::config::endpoint::Params::builder()
10964            .region("us-west-2".to_string())
10965            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
10966            .use_fips(false)
10967            .use_dual_stack(true)
10968            .accelerate(false)
10969            .disable_s3_express_session_auth(true)
10970            .build()
10971            .expect("invalid params");
10972        let resolver = crate::config::endpoint::DefaultResolver::new();
10973        let endpoint = resolver.resolve_endpoint(&params);
10974        let endpoint = endpoint.expect(
10975            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com",
10976        );
10977        assert_eq!(
10978            endpoint,
10979            ::aws_smithy_types::endpoint::Endpoint::builder()
10980                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10981                .property(
10982                    "authSchemes",
10983                    vec![{
10984                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
10985                        out.insert("name".to_string(), "sigv4".to_string().into());
10986                        out.insert("signingName".to_string(), "s3express".to_string().into());
10987                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
10988                        out.insert("disableDoubleEncoding".to_string(), true.into());
10989                        out
10990                    }
10991                    .into()]
10992                )
10993                .property("backend", "S3Express".to_string())
10994                .build()
10995        );
10996    }
10997
10998    /// Data Plane sigv4 auth with long zone (20 char) and FIPS with dualstack
10999    #[test]
11000    fn test_368() {
11001        let params = crate::config::endpoint::Params::builder()
11002            .region("us-west-2".to_string())
11003            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
11004            .use_fips(true)
11005            .use_dual_stack(true)
11006            .accelerate(false)
11007            .disable_s3_express_session_auth(true)
11008            .build()
11009            .expect("invalid params");
11010        let resolver = crate::config::endpoint::DefaultResolver::new();
11011        let endpoint = resolver.resolve_endpoint(&params);
11012        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
11013        assert_eq!(
11014            endpoint,
11015            ::aws_smithy_types::endpoint::Endpoint::builder()
11016                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
11017                .property(
11018                    "authSchemes",
11019                    vec![{
11020                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11021                        out.insert("name".to_string(), "sigv4".to_string().into());
11022                        out.insert("signingName".to_string(), "s3express".to_string().into());
11023                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11024                        out.insert("disableDoubleEncoding".to_string(), true.into());
11025                        out
11026                    }
11027                    .into()]
11028                )
11029                .property("backend", "S3Express".to_string())
11030                .build()
11031        );
11032    }
11033
11034    /// Control plane and FIPS with dualstack
11035    #[test]
11036    fn test_369() {
11037        let params = crate::config::endpoint::Params::builder()
11038            .region("us-east-1".to_string())
11039            .bucket("mybucket--test-ab1--x-s3".to_string())
11040            .use_fips(true)
11041            .use_dual_stack(true)
11042            .accelerate(false)
11043            .use_s3_express_control_endpoint(true)
11044            .build()
11045            .expect("invalid params");
11046        let resolver = crate::config::endpoint::DefaultResolver::new();
11047        let endpoint = resolver.resolve_endpoint(&params);
11048        let endpoint =
11049            endpoint.expect("Expected valid endpoint: https://s3express-control-fips.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
11050        assert_eq!(
11051            endpoint,
11052            ::aws_smithy_types::endpoint::Endpoint::builder()
11053                .url("https://s3express-control-fips.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
11054                .property(
11055                    "authSchemes",
11056                    vec![{
11057                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11058                        out.insert("name".to_string(), "sigv4".to_string().into());
11059                        out.insert("signingName".to_string(), "s3express".to_string().into());
11060                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
11061                        out.insert("disableDoubleEncoding".to_string(), true.into());
11062                        out
11063                    }
11064                    .into()]
11065                )
11066                .property("backend", "S3Express".to_string())
11067                .build()
11068        );
11069    }
11070
11071    /// Data plane with zone and dualstack and AP
11072    #[test]
11073    fn test_370() {
11074        let params = crate::config::endpoint::Params::builder()
11075            .region("us-west-2".to_string())
11076            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
11077            .use_fips(false)
11078            .use_dual_stack(true)
11079            .accelerate(false)
11080            .use_s3_express_control_endpoint(false)
11081            .build()
11082            .expect("invalid params");
11083        let resolver = crate::config::endpoint::DefaultResolver::new();
11084        let endpoint = resolver.resolve_endpoint(&params);
11085        let endpoint =
11086            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
11087        assert_eq!(
11088            endpoint,
11089            ::aws_smithy_types::endpoint::Endpoint::builder()
11090                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
11091                .property(
11092                    "authSchemes",
11093                    vec![{
11094                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11095                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
11096                        out.insert("signingName".to_string(), "s3express".to_string().into());
11097                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11098                        out.insert("disableDoubleEncoding".to_string(), true.into());
11099                        out
11100                    }
11101                    .into()]
11102                )
11103                .property("backend", "S3Express".to_string())
11104                .build()
11105        );
11106    }
11107
11108    /// Data plane with zone and FIPS with dualstack and AP
11109    #[test]
11110    fn test_371() {
11111        let params = crate::config::endpoint::Params::builder()
11112            .region("us-west-2".to_string())
11113            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
11114            .use_fips(true)
11115            .use_dual_stack(true)
11116            .accelerate(false)
11117            .use_s3_express_control_endpoint(false)
11118            .build()
11119            .expect("invalid params");
11120        let resolver = crate::config::endpoint::DefaultResolver::new();
11121        let endpoint = resolver.resolve_endpoint(&params);
11122        let endpoint = endpoint
11123            .expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
11124        assert_eq!(
11125            endpoint,
11126            ::aws_smithy_types::endpoint::Endpoint::builder()
11127                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
11128                .property(
11129                    "authSchemes",
11130                    vec![{
11131                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11132                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
11133                        out.insert("signingName".to_string(), "s3express".to_string().into());
11134                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11135                        out.insert("disableDoubleEncoding".to_string(), true.into());
11136                        out
11137                    }
11138                    .into()]
11139                )
11140                .property("backend", "S3Express".to_string())
11141                .build()
11142        );
11143    }
11144
11145    /// Data Plane sigv4 auth with zone and dualstack and AP
11146    #[test]
11147    fn test_372() {
11148        let params = crate::config::endpoint::Params::builder()
11149            .region("us-west-2".to_string())
11150            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
11151            .use_fips(false)
11152            .use_dual_stack(true)
11153            .accelerate(false)
11154            .disable_s3_express_session_auth(true)
11155            .build()
11156            .expect("invalid params");
11157        let resolver = crate::config::endpoint::DefaultResolver::new();
11158        let endpoint = resolver.resolve_endpoint(&params);
11159        let endpoint =
11160            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
11161        assert_eq!(
11162            endpoint,
11163            ::aws_smithy_types::endpoint::Endpoint::builder()
11164                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
11165                .property(
11166                    "authSchemes",
11167                    vec![{
11168                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11169                        out.insert("name".to_string(), "sigv4".to_string().into());
11170                        out.insert("signingName".to_string(), "s3express".to_string().into());
11171                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11172                        out.insert("disableDoubleEncoding".to_string(), true.into());
11173                        out
11174                    }
11175                    .into()]
11176                )
11177                .property("backend", "S3Express".to_string())
11178                .build()
11179        );
11180    }
11181
11182    /// Data Plane AP sigv4 auth with zone and FIPS with dualstack
11183    #[test]
11184    fn test_373() {
11185        let params = crate::config::endpoint::Params::builder()
11186            .region("us-west-2".to_string())
11187            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
11188            .use_fips(true)
11189            .use_dual_stack(true)
11190            .accelerate(false)
11191            .disable_s3_express_session_auth(true)
11192            .build()
11193            .expect("invalid params");
11194        let resolver = crate::config::endpoint::DefaultResolver::new();
11195        let endpoint = resolver.resolve_endpoint(&params);
11196        let endpoint = endpoint
11197            .expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
11198        assert_eq!(
11199            endpoint,
11200            ::aws_smithy_types::endpoint::Endpoint::builder()
11201                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
11202                .property(
11203                    "authSchemes",
11204                    vec![{
11205                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11206                        out.insert("name".to_string(), "sigv4".to_string().into());
11207                        out.insert("signingName".to_string(), "s3express".to_string().into());
11208                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11209                        out.insert("disableDoubleEncoding".to_string(), true.into());
11210                        out
11211                    }
11212                    .into()]
11213                )
11214                .property("backend", "S3Express".to_string())
11215                .build()
11216        );
11217    }
11218
11219    /// Data Plane with zone (9 char) and AP with dualstack
11220    #[test]
11221    fn test_374() {
11222        let params = crate::config::endpoint::Params::builder()
11223            .region("us-west-2".to_string())
11224            .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
11225            .use_fips(false)
11226            .use_dual_stack(true)
11227            .accelerate(false)
11228            .use_s3_express_control_endpoint(false)
11229            .build()
11230            .expect("invalid params");
11231        let resolver = crate::config::endpoint::DefaultResolver::new();
11232        let endpoint = resolver.resolve_endpoint(&params);
11233        let endpoint =
11234            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
11235        assert_eq!(
11236            endpoint,
11237            ::aws_smithy_types::endpoint::Endpoint::builder()
11238                .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
11239                .property(
11240                    "authSchemes",
11241                    vec![{
11242                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11243                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
11244                        out.insert("signingName".to_string(), "s3express".to_string().into());
11245                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11246                        out.insert("disableDoubleEncoding".to_string(), true.into());
11247                        out
11248                    }
11249                    .into()]
11250                )
11251                .property("backend", "S3Express".to_string())
11252                .build()
11253        );
11254    }
11255
11256    /// Data Plane with zone (9 char) and FIPS with AP and dualstack
11257    #[test]
11258    fn test_375() {
11259        let params = crate::config::endpoint::Params::builder()
11260            .region("us-west-2".to_string())
11261            .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
11262            .use_fips(true)
11263            .use_dual_stack(true)
11264            .accelerate(false)
11265            .use_s3_express_control_endpoint(false)
11266            .build()
11267            .expect("invalid params");
11268        let resolver = crate::config::endpoint::DefaultResolver::new();
11269        let endpoint = resolver.resolve_endpoint(&params);
11270        let endpoint = endpoint
11271            .expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
11272        assert_eq!(
11273            endpoint,
11274            ::aws_smithy_types::endpoint::Endpoint::builder()
11275                .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
11276                .property(
11277                    "authSchemes",
11278                    vec![{
11279                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11280                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
11281                        out.insert("signingName".to_string(), "s3express".to_string().into());
11282                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11283                        out.insert("disableDoubleEncoding".to_string(), true.into());
11284                        out
11285                    }
11286                    .into()]
11287                )
11288                .property("backend", "S3Express".to_string())
11289                .build()
11290        );
11291    }
11292
11293    /// Data Plane sigv4 auth with (9 char) zone and dualstack with AP
11294    #[test]
11295    fn test_376() {
11296        let params = crate::config::endpoint::Params::builder()
11297            .region("us-west-2".to_string())
11298            .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
11299            .use_fips(false)
11300            .use_dual_stack(true)
11301            .accelerate(false)
11302            .disable_s3_express_session_auth(true)
11303            .build()
11304            .expect("invalid params");
11305        let resolver = crate::config::endpoint::DefaultResolver::new();
11306        let endpoint = resolver.resolve_endpoint(&params);
11307        let endpoint =
11308            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
11309        assert_eq!(
11310            endpoint,
11311            ::aws_smithy_types::endpoint::Endpoint::builder()
11312                .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
11313                .property(
11314                    "authSchemes",
11315                    vec![{
11316                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11317                        out.insert("name".to_string(), "sigv4".to_string().into());
11318                        out.insert("signingName".to_string(), "s3express".to_string().into());
11319                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11320                        out.insert("disableDoubleEncoding".to_string(), true.into());
11321                        out
11322                    }
11323                    .into()]
11324                )
11325                .property("backend", "S3Express".to_string())
11326                .build()
11327        );
11328    }
11329
11330    /// Access Point sigv4 auth with (9 char) zone and FIPS with dualstack
11331    #[test]
11332    fn test_377() {
11333        let params = crate::config::endpoint::Params::builder()
11334            .region("us-west-2".to_string())
11335            .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
11336            .use_fips(true)
11337            .use_dual_stack(true)
11338            .accelerate(false)
11339            .disable_s3_express_session_auth(true)
11340            .build()
11341            .expect("invalid params");
11342        let resolver = crate::config::endpoint::DefaultResolver::new();
11343        let endpoint = resolver.resolve_endpoint(&params);
11344        let endpoint = endpoint
11345            .expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
11346        assert_eq!(
11347            endpoint,
11348            ::aws_smithy_types::endpoint::Endpoint::builder()
11349                .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
11350                .property(
11351                    "authSchemes",
11352                    vec![{
11353                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11354                        out.insert("name".to_string(), "sigv4".to_string().into());
11355                        out.insert("signingName".to_string(), "s3express".to_string().into());
11356                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11357                        out.insert("disableDoubleEncoding".to_string(), true.into());
11358                        out
11359                    }
11360                    .into()]
11361                )
11362                .property("backend", "S3Express".to_string())
11363                .build()
11364        );
11365    }
11366
11367    /// Data Plane with zone (13 char) and AP with dualstack
11368    #[test]
11369    fn test_378() {
11370        let params = crate::config::endpoint::Params::builder()
11371            .region("us-west-2".to_string())
11372            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
11373            .use_fips(false)
11374            .use_dual_stack(true)
11375            .accelerate(false)
11376            .use_s3_express_control_endpoint(false)
11377            .build()
11378            .expect("invalid params");
11379        let resolver = crate::config::endpoint::DefaultResolver::new();
11380        let endpoint = resolver.resolve_endpoint(&params);
11381        let endpoint = endpoint
11382            .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
11383        assert_eq!(
11384            endpoint,
11385            ::aws_smithy_types::endpoint::Endpoint::builder()
11386                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
11387                .property(
11388                    "authSchemes",
11389                    vec![{
11390                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11391                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
11392                        out.insert("signingName".to_string(), "s3express".to_string().into());
11393                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11394                        out.insert("disableDoubleEncoding".to_string(), true.into());
11395                        out
11396                    }
11397                    .into()]
11398                )
11399                .property("backend", "S3Express".to_string())
11400                .build()
11401        );
11402    }
11403
11404    /// Data Plane with zone (13 char) and AP with FIPS and dualstack
11405    #[test]
11406    fn test_379() {
11407        let params = crate::config::endpoint::Params::builder()
11408            .region("us-west-2".to_string())
11409            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
11410            .use_fips(true)
11411            .use_dual_stack(true)
11412            .accelerate(false)
11413            .use_s3_express_control_endpoint(false)
11414            .build()
11415            .expect("invalid params");
11416        let resolver = crate::config::endpoint::DefaultResolver::new();
11417        let endpoint = resolver.resolve_endpoint(&params);
11418        let endpoint = endpoint.expect(
11419            "Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com",
11420        );
11421        assert_eq!(
11422            endpoint,
11423            ::aws_smithy_types::endpoint::Endpoint::builder()
11424                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
11425                .property(
11426                    "authSchemes",
11427                    vec![{
11428                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11429                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
11430                        out.insert("signingName".to_string(), "s3express".to_string().into());
11431                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11432                        out.insert("disableDoubleEncoding".to_string(), true.into());
11433                        out
11434                    }
11435                    .into()]
11436                )
11437                .property("backend", "S3Express".to_string())
11438                .build()
11439        );
11440    }
11441
11442    /// Data Plane sigv4 auth with (13 char) zone with AP and dualstack
11443    #[test]
11444    fn test_380() {
11445        let params = crate::config::endpoint::Params::builder()
11446            .region("us-west-2".to_string())
11447            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
11448            .use_fips(false)
11449            .use_dual_stack(true)
11450            .accelerate(false)
11451            .disable_s3_express_session_auth(true)
11452            .build()
11453            .expect("invalid params");
11454        let resolver = crate::config::endpoint::DefaultResolver::new();
11455        let endpoint = resolver.resolve_endpoint(&params);
11456        let endpoint = endpoint
11457            .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
11458        assert_eq!(
11459            endpoint,
11460            ::aws_smithy_types::endpoint::Endpoint::builder()
11461                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
11462                .property(
11463                    "authSchemes",
11464                    vec![{
11465                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11466                        out.insert("name".to_string(), "sigv4".to_string().into());
11467                        out.insert("signingName".to_string(), "s3express".to_string().into());
11468                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11469                        out.insert("disableDoubleEncoding".to_string(), true.into());
11470                        out
11471                    }
11472                    .into()]
11473                )
11474                .property("backend", "S3Express".to_string())
11475                .build()
11476        );
11477    }
11478
11479    /// Data Plane sigv4 auth with (13 char) zone with AP and FIPS and dualstack
11480    #[test]
11481    fn test_381() {
11482        let params = crate::config::endpoint::Params::builder()
11483            .region("us-west-2".to_string())
11484            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
11485            .use_fips(true)
11486            .use_dual_stack(true)
11487            .accelerate(false)
11488            .disable_s3_express_session_auth(true)
11489            .build()
11490            .expect("invalid params");
11491        let resolver = crate::config::endpoint::DefaultResolver::new();
11492        let endpoint = resolver.resolve_endpoint(&params);
11493        let endpoint = endpoint.expect(
11494            "Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com",
11495        );
11496        assert_eq!(
11497            endpoint,
11498            ::aws_smithy_types::endpoint::Endpoint::builder()
11499                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
11500                .property(
11501                    "authSchemes",
11502                    vec![{
11503                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11504                        out.insert("name".to_string(), "sigv4".to_string().into());
11505                        out.insert("signingName".to_string(), "s3express".to_string().into());
11506                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11507                        out.insert("disableDoubleEncoding".to_string(), true.into());
11508                        out
11509                    }
11510                    .into()]
11511                )
11512                .property("backend", "S3Express".to_string())
11513                .build()
11514        );
11515    }
11516
11517    /// Data Plane with (14 char) zone and AP with dualstack
11518    #[test]
11519    fn test_382() {
11520        let params = crate::config::endpoint::Params::builder()
11521            .region("us-west-2".to_string())
11522            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
11523            .use_fips(false)
11524            .use_dual_stack(true)
11525            .accelerate(false)
11526            .use_s3_express_control_endpoint(false)
11527            .build()
11528            .expect("invalid params");
11529        let resolver = crate::config::endpoint::DefaultResolver::new();
11530        let endpoint = resolver.resolve_endpoint(&params);
11531        let endpoint = endpoint.expect(
11532            "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
11533        );
11534        assert_eq!(
11535            endpoint,
11536            ::aws_smithy_types::endpoint::Endpoint::builder()
11537                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
11538                .property(
11539                    "authSchemes",
11540                    vec![{
11541                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11542                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
11543                        out.insert("signingName".to_string(), "s3express".to_string().into());
11544                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11545                        out.insert("disableDoubleEncoding".to_string(), true.into());
11546                        out
11547                    }
11548                    .into()]
11549                )
11550                .property("backend", "S3Express".to_string())
11551                .build()
11552        );
11553    }
11554
11555    /// Data Plane with (14 char) zone and AP with FIPS and dualstack
11556    #[test]
11557    fn test_383() {
11558        let params = crate::config::endpoint::Params::builder()
11559            .region("us-west-2".to_string())
11560            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
11561            .use_fips(true)
11562            .use_dual_stack(true)
11563            .accelerate(false)
11564            .use_s3_express_control_endpoint(false)
11565            .build()
11566            .expect("invalid params");
11567        let resolver = crate::config::endpoint::DefaultResolver::new();
11568        let endpoint = resolver.resolve_endpoint(&params);
11569        let endpoint = endpoint.expect(
11570            "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
11571        );
11572        assert_eq!(
11573            endpoint,
11574            ::aws_smithy_types::endpoint::Endpoint::builder()
11575                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
11576                .property(
11577                    "authSchemes",
11578                    vec![{
11579                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11580                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
11581                        out.insert("signingName".to_string(), "s3express".to_string().into());
11582                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11583                        out.insert("disableDoubleEncoding".to_string(), true.into());
11584                        out
11585                    }
11586                    .into()]
11587                )
11588                .property("backend", "S3Express".to_string())
11589                .build()
11590        );
11591    }
11592
11593    /// Data Plane sigv4 auth with (14 char) zone and AP with dualstack
11594    #[test]
11595    fn test_384() {
11596        let params = crate::config::endpoint::Params::builder()
11597            .region("us-west-2".to_string())
11598            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
11599            .use_fips(false)
11600            .use_dual_stack(true)
11601            .accelerate(false)
11602            .disable_s3_express_session_auth(true)
11603            .build()
11604            .expect("invalid params");
11605        let resolver = crate::config::endpoint::DefaultResolver::new();
11606        let endpoint = resolver.resolve_endpoint(&params);
11607        let endpoint = endpoint.expect(
11608            "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
11609        );
11610        assert_eq!(
11611            endpoint,
11612            ::aws_smithy_types::endpoint::Endpoint::builder()
11613                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
11614                .property(
11615                    "authSchemes",
11616                    vec![{
11617                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11618                        out.insert("name".to_string(), "sigv4".to_string().into());
11619                        out.insert("signingName".to_string(), "s3express".to_string().into());
11620                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11621                        out.insert("disableDoubleEncoding".to_string(), true.into());
11622                        out
11623                    }
11624                    .into()]
11625                )
11626                .property("backend", "S3Express".to_string())
11627                .build()
11628        );
11629    }
11630
11631    /// Data Plane with (14 char) zone and AP with FIPS and dualstack
11632    #[test]
11633    fn test_385() {
11634        let params = crate::config::endpoint::Params::builder()
11635            .region("us-west-2".to_string())
11636            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
11637            .use_fips(true)
11638            .use_dual_stack(true)
11639            .accelerate(false)
11640            .disable_s3_express_session_auth(true)
11641            .build()
11642            .expect("invalid params");
11643        let resolver = crate::config::endpoint::DefaultResolver::new();
11644        let endpoint = resolver.resolve_endpoint(&params);
11645        let endpoint = endpoint.expect(
11646            "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
11647        );
11648        assert_eq!(
11649            endpoint,
11650            ::aws_smithy_types::endpoint::Endpoint::builder()
11651                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
11652                .property(
11653                    "authSchemes",
11654                    vec![{
11655                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11656                        out.insert("name".to_string(), "sigv4".to_string().into());
11657                        out.insert("signingName".to_string(), "s3express".to_string().into());
11658                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11659                        out.insert("disableDoubleEncoding".to_string(), true.into());
11660                        out
11661                    }
11662                    .into()]
11663                )
11664                .property("backend", "S3Express".to_string())
11665                .build()
11666        );
11667    }
11668
11669    /// Data Plane with (20 char) zone and AP with dualstack
11670    #[test]
11671    fn test_386() {
11672        let params = crate::config::endpoint::Params::builder()
11673            .region("us-west-2".to_string())
11674            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
11675            .use_fips(false)
11676            .use_dual_stack(true)
11677            .accelerate(false)
11678            .use_s3_express_control_endpoint(false)
11679            .build()
11680            .expect("invalid params");
11681        let resolver = crate::config::endpoint::DefaultResolver::new();
11682        let endpoint = resolver.resolve_endpoint(&params);
11683        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
11684        assert_eq!(
11685            endpoint,
11686            ::aws_smithy_types::endpoint::Endpoint::builder()
11687                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
11688                .property(
11689                    "authSchemes",
11690                    vec![{
11691                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11692                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
11693                        out.insert("signingName".to_string(), "s3express".to_string().into());
11694                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11695                        out.insert("disableDoubleEncoding".to_string(), true.into());
11696                        out
11697                    }
11698                    .into()]
11699                )
11700                .property("backend", "S3Express".to_string())
11701                .build()
11702        );
11703    }
11704
11705    /// Data Plane with (20 char) zone and AP with FIPS and dualstack
11706    #[test]
11707    fn test_387() {
11708        let params = crate::config::endpoint::Params::builder()
11709            .region("us-west-2".to_string())
11710            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
11711            .use_fips(true)
11712            .use_dual_stack(true)
11713            .accelerate(false)
11714            .use_s3_express_control_endpoint(false)
11715            .build()
11716            .expect("invalid params");
11717        let resolver = crate::config::endpoint::DefaultResolver::new();
11718        let endpoint = resolver.resolve_endpoint(&params);
11719        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
11720        assert_eq!(
11721            endpoint,
11722            ::aws_smithy_types::endpoint::Endpoint::builder()
11723                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
11724                .property(
11725                    "authSchemes",
11726                    vec![{
11727                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11728                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
11729                        out.insert("signingName".to_string(), "s3express".to_string().into());
11730                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11731                        out.insert("disableDoubleEncoding".to_string(), true.into());
11732                        out
11733                    }
11734                    .into()]
11735                )
11736                .property("backend", "S3Express".to_string())
11737                .build()
11738        );
11739    }
11740
11741    /// Data plane AP with sigv4 and dualstack
11742    #[test]
11743    fn test_388() {
11744        let params = crate::config::endpoint::Params::builder()
11745            .region("us-west-2".to_string())
11746            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
11747            .use_fips(false)
11748            .use_dual_stack(true)
11749            .accelerate(false)
11750            .disable_s3_express_session_auth(true)
11751            .build()
11752            .expect("invalid params");
11753        let resolver = crate::config::endpoint::DefaultResolver::new();
11754        let endpoint = resolver.resolve_endpoint(&params);
11755        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
11756        assert_eq!(
11757            endpoint,
11758            ::aws_smithy_types::endpoint::Endpoint::builder()
11759                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
11760                .property(
11761                    "authSchemes",
11762                    vec![{
11763                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11764                        out.insert("name".to_string(), "sigv4".to_string().into());
11765                        out.insert("signingName".to_string(), "s3express".to_string().into());
11766                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11767                        out.insert("disableDoubleEncoding".to_string(), true.into());
11768                        out
11769                    }
11770                    .into()]
11771                )
11772                .property("backend", "S3Express".to_string())
11773                .build()
11774        );
11775    }
11776
11777    /// Data plane AP sigv4 with fips and dualstack
11778    #[test]
11779    fn test_389() {
11780        let params = crate::config::endpoint::Params::builder()
11781            .region("us-west-2".to_string())
11782            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
11783            .use_fips(true)
11784            .use_dual_stack(true)
11785            .accelerate(false)
11786            .disable_s3_express_session_auth(true)
11787            .build()
11788            .expect("invalid params");
11789        let resolver = crate::config::endpoint::DefaultResolver::new();
11790        let endpoint = resolver.resolve_endpoint(&params);
11791        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
11792        assert_eq!(
11793            endpoint,
11794            ::aws_smithy_types::endpoint::Endpoint::builder()
11795                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
11796                .property(
11797                    "authSchemes",
11798                    vec![{
11799                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11800                        out.insert("name".to_string(), "sigv4".to_string().into());
11801                        out.insert("signingName".to_string(), "s3express".to_string().into());
11802                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
11803                        out.insert("disableDoubleEncoding".to_string(), true.into());
11804                        out
11805                    }
11806                    .into()]
11807                )
11808                .property("backend", "S3Express".to_string())
11809                .build()
11810        );
11811    }
11812
11813    /// Control plane with dualstack and bucket
11814    #[test]
11815    fn test_390() {
11816        let params = crate::config::endpoint::Params::builder()
11817            .region("us-east-1".to_string())
11818            .bucket("mybucket--test-ab1--x-s3".to_string())
11819            .use_fips(false)
11820            .use_dual_stack(true)
11821            .accelerate(false)
11822            .use_s3_express_control_endpoint(true)
11823            .build()
11824            .expect("invalid params");
11825        let resolver = crate::config::endpoint::DefaultResolver::new();
11826        let endpoint = resolver.resolve_endpoint(&params);
11827        let endpoint =
11828            endpoint.expect("Expected valid endpoint: https://s3express-control.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
11829        assert_eq!(
11830            endpoint,
11831            ::aws_smithy_types::endpoint::Endpoint::builder()
11832                .url("https://s3express-control.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
11833                .property(
11834                    "authSchemes",
11835                    vec![{
11836                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
11837                        out.insert("name".to_string(), "sigv4".to_string().into());
11838                        out.insert("signingName".to_string(), "s3express".to_string().into());
11839                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
11840                        out.insert("disableDoubleEncoding".to_string(), true.into());
11841                        out
11842                    }
11843                    .into()]
11844                )
11845                .property("backend", "S3Express".to_string())
11846                .build()
11847        );
11848    }
11849}
11850
11851/// Endpoint resolver trait specific to Amazon Simple Storage Service
11852pub trait ResolveEndpoint: ::std::marker::Send + ::std::marker::Sync + ::std::fmt::Debug {
11853    /// Resolve an endpoint with the given parameters
11854    fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a>;
11855
11856    /// Convert this service-specific resolver into a `SharedEndpointResolver`
11857    ///
11858    /// The resulting resolver will downcast `EndpointResolverParams` into `crate::config::endpoint::Params`.
11859    fn into_shared_resolver(self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver
11860    where
11861        Self: Sized + 'static,
11862    {
11863        ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
11864    }
11865}
11866
11867#[derive(Debug)]
11868struct DowncastParams<T>(T);
11869impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
11870where
11871    T: ResolveEndpoint,
11872{
11873    fn resolve_endpoint<'a>(
11874        &'a self,
11875        params: &'a ::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams,
11876    ) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
11877        let ep = match params.get::<crate::config::endpoint::Params>() {
11878            Some(params) => self.0.resolve_endpoint(params),
11879            None => ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(Err("params of expected type was not present".into())),
11880        };
11881        ep
11882    }
11883}
11884
11885/// The default endpoint resolver
11886#[derive(Debug, Default)]
11887pub struct DefaultResolver {
11888    partition_resolver: crate::endpoint_lib::partition::PartitionResolver,
11889}
11890
11891impl DefaultResolver {
11892    /// Create a new endpoint resolver with default settings
11893    pub fn new() -> Self {
11894        Self {
11895            partition_resolver: crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER.clone(),
11896        }
11897    }
11898
11899    fn resolve_endpoint(
11900        &self,
11901        params: &crate::config::endpoint::Params,
11902    ) -> ::std::result::Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_runtime_api::box_error::BoxError> {
11903        let mut diagnostic_collector = crate::endpoint_lib::diagnostic::DiagnosticCollector::new();
11904        Ok(
11905            crate::config::endpoint::internals::resolve_endpoint(params, &mut diagnostic_collector, &self.partition_resolver)
11906                .map_err(|err| err.with_source(diagnostic_collector.take_last_error()))?,
11907        )
11908    }
11909}
11910
11911impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
11912    fn resolve_endpoint(&self, params: &crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'_> {
11913        ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(self.resolve_endpoint(params))
11914    }
11915}
11916
11917#[non_exhaustive]
11918#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
11919/// Configuration parameters for resolving the correct endpoint
11920pub struct Params {
11921    /// The S3 bucket used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 bucket.
11922    pub(crate) bucket: ::std::option::Option<::std::string::String>,
11923    /// The AWS region used to dispatch the request.
11924    pub(crate) region: ::std::option::Option<::std::string::String>,
11925    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
11926    pub(crate) use_fips: bool,
11927    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
11928    pub(crate) use_dual_stack: bool,
11929    /// Override the endpoint used to send this request
11930    pub(crate) endpoint: ::std::option::Option<::std::string::String>,
11931    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
11932    pub(crate) force_path_style: bool,
11933    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
11934    pub(crate) accelerate: bool,
11935    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
11936    pub(crate) use_global_endpoint: bool,
11937    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
11938    pub(crate) use_object_lambda_endpoint: ::std::option::Option<bool>,
11939    /// The S3 Key used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Key.
11940    pub(crate) key: ::std::option::Option<::std::string::String>,
11941    /// The S3 Prefix used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Prefix.
11942    pub(crate) prefix: ::std::option::Option<::std::string::String>,
11943    /// The Copy Source used for Copy Object request. This is an optional parameter that will be set automatically for operations that are scoped to Copy Source.
11944    pub(crate) copy_source: ::std::option::Option<::std::string::String>,
11945    /// Internal parameter to disable Access Point Buckets
11946    pub(crate) disable_access_points: ::std::option::Option<bool>,
11947    /// Whether multi-region access points (MRAP) should be disabled.
11948    pub(crate) disable_multi_region_access_points: bool,
11949    /// When an Access Point ARN is provided and this flag is enabled, the SDK MUST use the ARN's region when constructing the endpoint instead of the client's configured region.
11950    pub(crate) use_arn_region: ::std::option::Option<bool>,
11951    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
11952    pub(crate) use_s3_express_control_endpoint: ::std::option::Option<bool>,
11953    /// Parameter to indicate whether S3Express session auth should be disabled
11954    pub(crate) disable_s3_express_session_auth: ::std::option::Option<bool>,
11955}
11956impl Params {
11957    /// Create a builder for [`Params`]
11958    pub fn builder() -> crate::config::endpoint::ParamsBuilder {
11959        crate::config::endpoint::ParamsBuilder::default()
11960    }
11961    /// The S3 bucket used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 bucket.
11962    pub fn bucket(&self) -> ::std::option::Option<&str> {
11963        self.bucket.as_deref()
11964    }
11965    /// The AWS region used to dispatch the request.
11966    pub fn region(&self) -> ::std::option::Option<&str> {
11967        self.region.as_deref()
11968    }
11969    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
11970    pub fn use_fips(&self) -> ::std::option::Option<bool> {
11971        Some(self.use_fips)
11972    }
11973    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
11974    pub fn use_dual_stack(&self) -> ::std::option::Option<bool> {
11975        Some(self.use_dual_stack)
11976    }
11977    /// Override the endpoint used to send this request
11978    pub fn endpoint(&self) -> ::std::option::Option<&str> {
11979        self.endpoint.as_deref()
11980    }
11981    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
11982    pub fn force_path_style(&self) -> ::std::option::Option<bool> {
11983        Some(self.force_path_style)
11984    }
11985    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
11986    pub fn accelerate(&self) -> ::std::option::Option<bool> {
11987        Some(self.accelerate)
11988    }
11989    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
11990    pub fn use_global_endpoint(&self) -> ::std::option::Option<bool> {
11991        Some(self.use_global_endpoint)
11992    }
11993    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
11994    pub fn use_object_lambda_endpoint(&self) -> ::std::option::Option<bool> {
11995        self.use_object_lambda_endpoint
11996    }
11997    /// The S3 Key used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Key.
11998    pub fn key(&self) -> ::std::option::Option<&str> {
11999        self.key.as_deref()
12000    }
12001    /// The S3 Prefix used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Prefix.
12002    pub fn prefix(&self) -> ::std::option::Option<&str> {
12003        self.prefix.as_deref()
12004    }
12005    /// The Copy Source used for Copy Object request. This is an optional parameter that will be set automatically for operations that are scoped to Copy Source.
12006    pub fn copy_source(&self) -> ::std::option::Option<&str> {
12007        self.copy_source.as_deref()
12008    }
12009    /// Internal parameter to disable Access Point Buckets
12010    pub fn disable_access_points(&self) -> ::std::option::Option<bool> {
12011        self.disable_access_points
12012    }
12013    /// Whether multi-region access points (MRAP) should be disabled.
12014    pub fn disable_multi_region_access_points(&self) -> ::std::option::Option<bool> {
12015        Some(self.disable_multi_region_access_points)
12016    }
12017    /// When an Access Point ARN is provided and this flag is enabled, the SDK MUST use the ARN's region when constructing the endpoint instead of the client's configured region.
12018    pub fn use_arn_region(&self) -> ::std::option::Option<bool> {
12019        self.use_arn_region
12020    }
12021    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
12022    pub fn use_s3_express_control_endpoint(&self) -> ::std::option::Option<bool> {
12023        self.use_s3_express_control_endpoint
12024    }
12025    /// Parameter to indicate whether S3Express session auth should be disabled
12026    pub fn disable_s3_express_session_auth(&self) -> ::std::option::Option<bool> {
12027        self.disable_s3_express_session_auth
12028    }
12029}
12030
12031/// Builder for [`Params`]
12032#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
12033pub struct ParamsBuilder {
12034    bucket: ::std::option::Option<::std::string::String>,
12035    region: ::std::option::Option<::std::string::String>,
12036    use_fips: ::std::option::Option<bool>,
12037    use_dual_stack: ::std::option::Option<bool>,
12038    endpoint: ::std::option::Option<::std::string::String>,
12039    force_path_style: ::std::option::Option<bool>,
12040    accelerate: ::std::option::Option<bool>,
12041    use_global_endpoint: ::std::option::Option<bool>,
12042    use_object_lambda_endpoint: ::std::option::Option<bool>,
12043    key: ::std::option::Option<::std::string::String>,
12044    prefix: ::std::option::Option<::std::string::String>,
12045    copy_source: ::std::option::Option<::std::string::String>,
12046    disable_access_points: ::std::option::Option<bool>,
12047    disable_multi_region_access_points: ::std::option::Option<bool>,
12048    use_arn_region: ::std::option::Option<bool>,
12049    use_s3_express_control_endpoint: ::std::option::Option<bool>,
12050    disable_s3_express_session_auth: ::std::option::Option<bool>,
12051}
12052impl ParamsBuilder {
12053    /// Consume this builder, creating [`Params`].
12054    pub fn build(self) -> ::std::result::Result<crate::config::endpoint::Params, crate::config::endpoint::InvalidParams> {
12055        Ok(
12056            #[allow(clippy::unnecessary_lazy_evaluations)]
12057            crate::config::endpoint::Params {
12058                bucket: self.bucket,
12059                region: self.region,
12060                use_fips: self
12061                    .use_fips
12062                    .or_else(|| Some(false))
12063                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_fips"))?,
12064                use_dual_stack: self
12065                    .use_dual_stack
12066                    .or_else(|| Some(false))
12067                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_dual_stack"))?,
12068                endpoint: self.endpoint,
12069                force_path_style: self
12070                    .force_path_style
12071                    .or_else(|| Some(false))
12072                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("force_path_style"))?,
12073                accelerate: self
12074                    .accelerate
12075                    .or_else(|| Some(false))
12076                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("accelerate"))?,
12077                use_global_endpoint: self
12078                    .use_global_endpoint
12079                    .or_else(|| Some(false))
12080                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_global_endpoint"))?,
12081                use_object_lambda_endpoint: self.use_object_lambda_endpoint,
12082                key: self.key,
12083                prefix: self.prefix,
12084                copy_source: self.copy_source,
12085                disable_access_points: self.disable_access_points,
12086                disable_multi_region_access_points: self
12087                    .disable_multi_region_access_points
12088                    .or_else(|| Some(false))
12089                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("disable_multi_region_access_points"))?,
12090                use_arn_region: self.use_arn_region,
12091                use_s3_express_control_endpoint: self.use_s3_express_control_endpoint,
12092                disable_s3_express_session_auth: self.disable_s3_express_session_auth,
12093            },
12094        )
12095    }
12096    /// Sets the value for bucket
12097    ///
12098    /// The S3 bucket used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 bucket.
12099    pub fn bucket(mut self, value: impl Into<::std::string::String>) -> Self {
12100        self.bucket = Some(value.into());
12101        self
12102    }
12103
12104    /// Sets the value for bucket
12105    ///
12106    /// The S3 bucket used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 bucket.
12107    pub fn set_bucket(mut self, param: Option<::std::string::String>) -> Self {
12108        self.bucket = param;
12109        self
12110    }
12111    /// Sets the value for region
12112    ///
12113    /// The AWS region used to dispatch the request.
12114    pub fn region(mut self, value: impl Into<::std::string::String>) -> Self {
12115        self.region = Some(value.into());
12116        self
12117    }
12118
12119    /// Sets the value for region
12120    ///
12121    /// The AWS region used to dispatch the request.
12122    pub fn set_region(mut self, param: Option<::std::string::String>) -> Self {
12123        self.region = param;
12124        self
12125    }
12126    /// Sets the value for use_fips
12127    ///
12128    /// When unset, this parameter has a default value of `false`.
12129    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
12130    pub fn use_fips(mut self, value: impl Into<bool>) -> Self {
12131        self.use_fips = Some(value.into());
12132        self
12133    }
12134
12135    /// Sets the value for use_fips
12136    ///
12137    /// When unset, this parameter has a default value of `false`.
12138    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
12139    pub fn set_use_fips(mut self, param: Option<bool>) -> Self {
12140        self.use_fips = param;
12141        self
12142    }
12143    /// Sets the value for use_dual_stack
12144    ///
12145    /// When unset, this parameter has a default value of `false`.
12146    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
12147    pub fn use_dual_stack(mut self, value: impl Into<bool>) -> Self {
12148        self.use_dual_stack = Some(value.into());
12149        self
12150    }
12151
12152    /// Sets the value for use_dual_stack
12153    ///
12154    /// When unset, this parameter has a default value of `false`.
12155    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
12156    pub fn set_use_dual_stack(mut self, param: Option<bool>) -> Self {
12157        self.use_dual_stack = param;
12158        self
12159    }
12160    /// Sets the value for endpoint
12161    ///
12162    /// Override the endpoint used to send this request
12163    pub fn endpoint(mut self, value: impl Into<::std::string::String>) -> Self {
12164        self.endpoint = Some(value.into());
12165        self
12166    }
12167
12168    /// Sets the value for endpoint
12169    ///
12170    /// Override the endpoint used to send this request
12171    pub fn set_endpoint(mut self, param: Option<::std::string::String>) -> Self {
12172        self.endpoint = param;
12173        self
12174    }
12175    /// Sets the value for force_path_style
12176    ///
12177    /// When unset, this parameter has a default value of `false`.
12178    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
12179    pub fn force_path_style(mut self, value: impl Into<bool>) -> Self {
12180        self.force_path_style = Some(value.into());
12181        self
12182    }
12183
12184    /// Sets the value for force_path_style
12185    ///
12186    /// When unset, this parameter has a default value of `false`.
12187    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
12188    pub fn set_force_path_style(mut self, param: Option<bool>) -> Self {
12189        self.force_path_style = param;
12190        self
12191    }
12192    /// Sets the value for accelerate
12193    ///
12194    /// When unset, this parameter has a default value of `false`.
12195    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
12196    pub fn accelerate(mut self, value: impl Into<bool>) -> Self {
12197        self.accelerate = Some(value.into());
12198        self
12199    }
12200
12201    /// Sets the value for accelerate
12202    ///
12203    /// When unset, this parameter has a default value of `false`.
12204    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
12205    pub fn set_accelerate(mut self, param: Option<bool>) -> Self {
12206        self.accelerate = param;
12207        self
12208    }
12209    /// Sets the value for use_global_endpoint
12210    ///
12211    /// When unset, this parameter has a default value of `false`.
12212    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
12213    pub fn use_global_endpoint(mut self, value: impl Into<bool>) -> Self {
12214        self.use_global_endpoint = Some(value.into());
12215        self
12216    }
12217
12218    /// Sets the value for use_global_endpoint
12219    ///
12220    /// When unset, this parameter has a default value of `false`.
12221    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
12222    pub fn set_use_global_endpoint(mut self, param: Option<bool>) -> Self {
12223        self.use_global_endpoint = param;
12224        self
12225    }
12226    /// Sets the value for use_object_lambda_endpoint
12227    ///
12228    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
12229    pub fn use_object_lambda_endpoint(mut self, value: impl Into<bool>) -> Self {
12230        self.use_object_lambda_endpoint = Some(value.into());
12231        self
12232    }
12233
12234    /// Sets the value for use_object_lambda_endpoint
12235    ///
12236    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
12237    pub fn set_use_object_lambda_endpoint(mut self, param: Option<bool>) -> Self {
12238        self.use_object_lambda_endpoint = param;
12239        self
12240    }
12241    /// Sets the value for key
12242    ///
12243    /// The S3 Key used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Key.
12244    pub fn key(mut self, value: impl Into<::std::string::String>) -> Self {
12245        self.key = Some(value.into());
12246        self
12247    }
12248
12249    /// Sets the value for key
12250    ///
12251    /// The S3 Key used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Key.
12252    pub fn set_key(mut self, param: Option<::std::string::String>) -> Self {
12253        self.key = param;
12254        self
12255    }
12256    /// Sets the value for prefix
12257    ///
12258    /// The S3 Prefix used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Prefix.
12259    pub fn prefix(mut self, value: impl Into<::std::string::String>) -> Self {
12260        self.prefix = Some(value.into());
12261        self
12262    }
12263
12264    /// Sets the value for prefix
12265    ///
12266    /// The S3 Prefix used to send the request. This is an optional parameter that will be set automatically for operations that are scoped to an S3 Prefix.
12267    pub fn set_prefix(mut self, param: Option<::std::string::String>) -> Self {
12268        self.prefix = param;
12269        self
12270    }
12271    /// Sets the value for copy_source
12272    ///
12273    /// The Copy Source used for Copy Object request. This is an optional parameter that will be set automatically for operations that are scoped to Copy Source.
12274    pub fn copy_source(mut self, value: impl Into<::std::string::String>) -> Self {
12275        self.copy_source = Some(value.into());
12276        self
12277    }
12278
12279    /// Sets the value for copy_source
12280    ///
12281    /// The Copy Source used for Copy Object request. This is an optional parameter that will be set automatically for operations that are scoped to Copy Source.
12282    pub fn set_copy_source(mut self, param: Option<::std::string::String>) -> Self {
12283        self.copy_source = param;
12284        self
12285    }
12286    /// Sets the value for disable_access_points
12287    ///
12288    /// Internal parameter to disable Access Point Buckets
12289    pub fn disable_access_points(mut self, value: impl Into<bool>) -> Self {
12290        self.disable_access_points = Some(value.into());
12291        self
12292    }
12293
12294    /// Sets the value for disable_access_points
12295    ///
12296    /// Internal parameter to disable Access Point Buckets
12297    pub fn set_disable_access_points(mut self, param: Option<bool>) -> Self {
12298        self.disable_access_points = param;
12299        self
12300    }
12301    /// Sets the value for disable_multi_region_access_points
12302    ///
12303    /// When unset, this parameter has a default value of `false`.
12304    /// Whether multi-region access points (MRAP) should be disabled.
12305    pub fn disable_multi_region_access_points(mut self, value: impl Into<bool>) -> Self {
12306        self.disable_multi_region_access_points = Some(value.into());
12307        self
12308    }
12309
12310    /// Sets the value for disable_multi_region_access_points
12311    ///
12312    /// When unset, this parameter has a default value of `false`.
12313    /// Whether multi-region access points (MRAP) should be disabled.
12314    pub fn set_disable_multi_region_access_points(mut self, param: Option<bool>) -> Self {
12315        self.disable_multi_region_access_points = param;
12316        self
12317    }
12318    /// Sets the value for use_arn_region
12319    ///
12320    /// When an Access Point ARN is provided and this flag is enabled, the SDK MUST use the ARN's region when constructing the endpoint instead of the client's configured region.
12321    pub fn use_arn_region(mut self, value: impl Into<bool>) -> Self {
12322        self.use_arn_region = Some(value.into());
12323        self
12324    }
12325
12326    /// Sets the value for use_arn_region
12327    ///
12328    /// When an Access Point ARN is provided and this flag is enabled, the SDK MUST use the ARN's region when constructing the endpoint instead of the client's configured region.
12329    pub fn set_use_arn_region(mut self, param: Option<bool>) -> Self {
12330        self.use_arn_region = param;
12331        self
12332    }
12333    /// Sets the value for use_s3_express_control_endpoint
12334    ///
12335    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
12336    pub fn use_s3_express_control_endpoint(mut self, value: impl Into<bool>) -> Self {
12337        self.use_s3_express_control_endpoint = Some(value.into());
12338        self
12339    }
12340
12341    /// Sets the value for use_s3_express_control_endpoint
12342    ///
12343    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
12344    pub fn set_use_s3_express_control_endpoint(mut self, param: Option<bool>) -> Self {
12345        self.use_s3_express_control_endpoint = param;
12346        self
12347    }
12348    /// Sets the value for disable_s3_express_session_auth
12349    ///
12350    /// Parameter to indicate whether S3Express session auth should be disabled
12351    pub fn disable_s3_express_session_auth(mut self, value: impl Into<bool>) -> Self {
12352        self.disable_s3_express_session_auth = Some(value.into());
12353        self
12354    }
12355
12356    /// Sets the value for disable_s3_express_session_auth
12357    ///
12358    /// Parameter to indicate whether S3Express session auth should be disabled
12359    pub fn set_disable_s3_express_session_auth(mut self, param: Option<bool>) -> Self {
12360        self.disable_s3_express_session_auth = param;
12361        self
12362    }
12363}
12364
12365/// An error that occurred during endpoint resolution
12366#[derive(Debug)]
12367pub struct InvalidParams {
12368    field: std::borrow::Cow<'static, str>,
12369    kind: InvalidParamsErrorKind,
12370}
12371
12372/// The kind of invalid parameter error
12373#[derive(Debug)]
12374enum InvalidParamsErrorKind {
12375    MissingField,
12376    InvalidValue { message: &'static str },
12377}
12378
12379impl InvalidParams {
12380    #[allow(dead_code)]
12381    fn missing(field: &'static str) -> Self {
12382        Self {
12383            field: field.into(),
12384            kind: InvalidParamsErrorKind::MissingField,
12385        }
12386    }
12387
12388    #[allow(dead_code)]
12389    fn invalid_value(field: &'static str, message: &'static str) -> Self {
12390        Self {
12391            field: field.into(),
12392            kind: InvalidParamsErrorKind::InvalidValue { message },
12393        }
12394    }
12395}
12396
12397impl std::fmt::Display for InvalidParams {
12398    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12399        match self.kind {
12400            InvalidParamsErrorKind::MissingField => write!(f, "a required field was missing: `{}`", self.field),
12401            InvalidParamsErrorKind::InvalidValue { message } => write!(f, "invalid value for field: `{}` - {}", self.field, message),
12402        }
12403    }
12404}
12405
12406impl std::error::Error for InvalidParams {}
12407
12408mod internals;
aws_sdk_s3/config/endpoint.rs

aws_sdk_s3/config/
endpoint.rs
