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#[cfg(test)]
7mod test {
8
9    /// region is not a valid DNS-suffix
10    #[test]
11    fn test_1() {
12        let params = crate::config::endpoint::Params::builder()
13            .region("a b".to_string())
14            .use_fips(false)
15            .use_dual_stack(false)
16            .accelerate(false)
17            .build()
18            .expect("invalid params");
19        let resolver = crate::config::endpoint::DefaultResolver::new();
20        let endpoint = resolver.resolve_endpoint(&params);
21        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [region is not a valid DNS-suffix]");
22        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
23    }
24
25    /// Invalid access point ARN: Not S3
26    #[test]
27    fn test_2() {
28        let params = crate::config::endpoint::Params::builder()
29            .region("us-east-1".to_string())
30            .use_fips(false)
31            .use_dual_stack(false)
32            .accelerate(false)
33            .bucket("arn:aws:not-s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
34            .build()
35            .expect("invalid params");
36        let resolver = crate::config::endpoint::DefaultResolver::new();
37        let endpoint = resolver.resolve_endpoint(&params);
38        let error =
39            endpoint.expect_err("expected error: Invalid ARN: The ARN was not for the S3 service, found: not-s3 [Invalid access point ARN: Not S3]");
40        assert_eq!(format!("{}", error), "Invalid ARN: The ARN was not for the S3 service, found: not-s3")
41    }
42
43    /// Invalid access point ARN: invalid resource
44    #[test]
45    fn test_3() {
46        let params = crate::config::endpoint::Params::builder()
47            .region("us-east-1".to_string())
48            .use_fips(false)
49            .use_dual_stack(false)
50            .accelerate(false)
51            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint:more-data".to_string())
52            .build()
53            .expect("invalid params");
54        let resolver = crate::config::endpoint::DefaultResolver::new();
55        let endpoint = resolver.resolve_endpoint(&params);
56        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]");
57        assert_eq!(
58            format!("{}", error),
59            "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`."
60        )
61    }
62
63    /// Invalid access point ARN: invalid no ap name
64    #[test]
65    fn test_4() {
66        let params = crate::config::endpoint::Params::builder()
67            .region("us-east-1".to_string())
68            .use_fips(false)
69            .use_dual_stack(false)
70            .accelerate(false)
71            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:".to_string())
72            .build()
73            .expect("invalid params");
74        let resolver = crate::config::endpoint::DefaultResolver::new();
75        let endpoint = resolver.resolve_endpoint(&params);
76        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]");
77        assert_eq!(
78            format!("{}", error),
79            "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided"
80        )
81    }
82
83    /// Invalid access point ARN: AccountId is invalid
84    #[test]
85    fn test_5() {
86        let params = crate::config::endpoint::Params::builder()
87            .region("us-east-1".to_string())
88            .use_fips(false)
89            .use_dual_stack(false)
90            .accelerate(false)
91            .bucket("arn:aws:s3:us-west-2:123456_789012:accesspoint:apname".to_string())
92            .build()
93            .expect("invalid params");
94        let resolver = crate::config::endpoint::DefaultResolver::new();
95        let endpoint = resolver.resolve_endpoint(&params);
96        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]");
97        assert_eq!(
98            format!("{}", error),
99            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123456_789012`"
100        )
101    }
102
103    /// Invalid access point ARN: access point name is invalid
104    #[test]
105    fn test_6() {
106        let params = crate::config::endpoint::Params::builder()
107            .region("us-east-1".to_string())
108            .use_fips(false)
109            .use_dual_stack(false)
110            .accelerate(false)
111            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:ap_name".to_string())
112            .build()
113            .expect("invalid params");
114        let resolver = crate::config::endpoint::DefaultResolver::new();
115        let endpoint = resolver.resolve_endpoint(&params);
116        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]");
117        assert_eq!(
118            format!("{}", error),
119            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `ap_name`"
120        )
121    }
122
123    /// Access points (disable access points explicitly false)
124    #[test]
125    fn test_7() {
126        let params = crate::config::endpoint::Params::builder()
127            .region("us-east-1".to_string())
128            .use_fips(false)
129            .use_dual_stack(false)
130            .accelerate(false)
131            .disable_access_points(false)
132            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
133            .build()
134            .expect("invalid params");
135        let resolver = crate::config::endpoint::DefaultResolver::new();
136        let endpoint = resolver.resolve_endpoint(&params);
137        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
138        assert_eq!(
139            endpoint,
140            ::aws_smithy_types::endpoint::Endpoint::builder()
141                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
142                .property(
143                    "authSchemes",
144                    vec![{
145                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
146                        out.insert("name".to_string(), "sigv4".to_string().into());
147                        out.insert("signingName".to_string(), "s3".to_string().into());
148                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
149                        out.insert("disableDoubleEncoding".to_string(), true.into());
150                        out
151                    }
152                    .into()]
153                )
154                .build()
155        );
156    }
157
158    /// Access points: partition does not support FIPS
159    #[test]
160    fn test_8() {
161        let params = crate::config::endpoint::Params::builder()
162            .region("cn-north-1".to_string())
163            .use_fips(true)
164            .use_dual_stack(false)
165            .accelerate(false)
166            .bucket("arn:aws:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
167            .build()
168            .expect("invalid params");
169        let resolver = crate::config::endpoint::DefaultResolver::new();
170        let endpoint = resolver.resolve_endpoint(&params);
171        let error = endpoint.expect_err("expected error: Partition does not support FIPS [Access points: partition does not support FIPS]");
172        assert_eq!(format!("{}", error), "Partition does not support FIPS")
173    }
174
175    /// Bucket region is invalid
176    #[test]
177    fn test_9() {
178        let params = crate::config::endpoint::Params::builder()
179            .region("us-east-1".to_string())
180            .use_fips(false)
181            .use_dual_stack(false)
182            .accelerate(false)
183            .disable_access_points(false)
184            .bucket("arn:aws:s3:us-west -2:123456789012:accesspoint:myendpoint".to_string())
185            .build()
186            .expect("invalid params");
187        let resolver = crate::config::endpoint::DefaultResolver::new();
188        let endpoint = resolver.resolve_endpoint(&params);
189        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-west -2` (invalid DNS name) [Bucket region is invalid]");
190        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-west -2` (invalid DNS name)")
191    }
192
193    /// Access points when Access points explicitly disabled (used for CreateBucket)
194    #[test]
195    fn test_10() {
196        let params = crate::config::endpoint::Params::builder()
197            .region("us-east-1".to_string())
198            .use_fips(false)
199            .use_dual_stack(false)
200            .accelerate(false)
201            .disable_access_points(true)
202            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
203            .build()
204            .expect("invalid params");
205        let resolver = crate::config::endpoint::DefaultResolver::new();
206        let endpoint = resolver.resolve_endpoint(&params);
207        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)]");
208        assert_eq!(format!("{}", error), "Access points are not supported for this operation")
209    }
210
211    /// missing arn type
212    #[test]
213    fn test_11() {
214        let params = crate::config::endpoint::Params::builder()
215            .region("us-east-1".to_string())
216            .use_fips(false)
217            .use_dual_stack(false)
218            .accelerate(false)
219            .disable_access_points(true)
220            .bucket("arn:aws:s3:us-west-2:123456789012:".to_string())
221            .build()
222            .expect("invalid params");
223        let resolver = crate::config::endpoint::DefaultResolver::new();
224        let endpoint = resolver.resolve_endpoint(&params);
225        let error = endpoint.expect_err("expected error: Invalid ARN: `arn:aws:s3:us-west-2:123456789012:` was not a valid ARN [missing arn type]");
226        assert_eq!(
227            format!("{}", error),
228            "Invalid ARN: `arn:aws:s3:us-west-2:123456789012:` was not a valid ARN"
229        )
230    }
231
232    /// SDK::Host + access point + Dualstack is an error
233    #[test]
234    fn test_12() {
235        let params = crate::config::endpoint::Params::builder()
236            .accelerate(false)
237            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
238            .force_path_style(false)
239            .endpoint("https://beta.example.com".to_string())
240            .region("cn-north-1".to_string())
241            .use_dual_stack(true)
242            .use_fips(false)
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(
248            "expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + access point + Dualstack is an error]",
249        );
250        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
251    }
252
253    /// Access point ARN with FIPS & Dualstack
254    #[test]
255    fn test_13() {
256        let params = crate::config::endpoint::Params::builder()
257            .region("us-east-1".to_string())
258            .use_fips(true)
259            .use_dual_stack(true)
260            .accelerate(false)
261            .disable_access_points(false)
262            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
263            .build()
264            .expect("invalid params");
265        let resolver = crate::config::endpoint::DefaultResolver::new();
266        let endpoint = resolver.resolve_endpoint(&params);
267        let endpoint =
268            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com");
269        assert_eq!(
270            endpoint,
271            ::aws_smithy_types::endpoint::Endpoint::builder()
272                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com")
273                .property(
274                    "authSchemes",
275                    vec![{
276                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
277                        out.insert("name".to_string(), "sigv4".to_string().into());
278                        out.insert("signingName".to_string(), "s3".to_string().into());
279                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
280                        out.insert("disableDoubleEncoding".to_string(), true.into());
281                        out
282                    }
283                    .into()]
284                )
285                .build()
286        );
287    }
288
289    /// Access point ARN with Dualstack
290    #[test]
291    fn test_14() {
292        let params = crate::config::endpoint::Params::builder()
293            .region("us-east-1".to_string())
294            .use_fips(false)
295            .use_dual_stack(true)
296            .accelerate(false)
297            .disable_access_points(false)
298            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
299            .build()
300            .expect("invalid params");
301        let resolver = crate::config::endpoint::DefaultResolver::new();
302        let endpoint = resolver.resolve_endpoint(&params);
303        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.dualstack.us-west-2.amazonaws.com");
304        assert_eq!(
305            endpoint,
306            ::aws_smithy_types::endpoint::Endpoint::builder()
307                .url("https://myendpoint-123456789012.s3-accesspoint.dualstack.us-west-2.amazonaws.com")
308                .property(
309                    "authSchemes",
310                    vec![{
311                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
312                        out.insert("name".to_string(), "sigv4".to_string().into());
313                        out.insert("signingName".to_string(), "s3".to_string().into());
314                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
315                        out.insert("disableDoubleEncoding".to_string(), true.into());
316                        out
317                    }
318                    .into()]
319                )
320                .build()
321        );
322    }
323
324    /// vanilla MRAP
325    #[test]
326    fn test_15() {
327        let params = crate::config::endpoint::Params::builder()
328            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
329            .region("us-east-1".to_string())
330            .disable_multi_region_access_points(false)
331            .use_fips(false)
332            .use_dual_stack(false)
333            .accelerate(false)
334            .build()
335            .expect("invalid params");
336        let resolver = crate::config::endpoint::DefaultResolver::new();
337        let endpoint = resolver.resolve_endpoint(&params);
338        let endpoint = endpoint.expect("Expected valid endpoint: https://mfzwi23gnjvgw.mrap.accesspoint.s3-global.amazonaws.com");
339        assert_eq!(
340            endpoint,
341            ::aws_smithy_types::endpoint::Endpoint::builder()
342                .url("https://mfzwi23gnjvgw.mrap.accesspoint.s3-global.amazonaws.com")
343                .property(
344                    "authSchemes",
345                    vec![{
346                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
347                        out.insert("name".to_string(), "sigv4a".to_string().into());
348                        out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
349                        out.insert("signingName".to_string(), "s3".to_string().into());
350                        out.insert("disableDoubleEncoding".to_string(), true.into());
351                        out
352                    }
353                    .into()]
354                )
355                .build()
356        );
357    }
358
359    /// MRAP does not support FIPS
360    #[test]
361    fn test_16() {
362        let params = crate::config::endpoint::Params::builder()
363            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
364            .region("us-east-1".to_string())
365            .disable_multi_region_access_points(false)
366            .use_fips(true)
367            .use_dual_stack(false)
368            .accelerate(false)
369            .build()
370            .expect("invalid params");
371        let resolver = crate::config::endpoint::DefaultResolver::new();
372        let endpoint = resolver.resolve_endpoint(&params);
373        let error = endpoint.expect_err("expected error: S3 MRAP does not support FIPS [MRAP does not support FIPS]");
374        assert_eq!(format!("{}", error), "S3 MRAP does not support FIPS")
375    }
376
377    /// MRAP does not support DualStack
378    #[test]
379    fn test_17() {
380        let params = crate::config::endpoint::Params::builder()
381            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
382            .region("us-east-1".to_string())
383            .disable_multi_region_access_points(false)
384            .use_fips(false)
385            .use_dual_stack(true)
386            .accelerate(false)
387            .build()
388            .expect("invalid params");
389        let resolver = crate::config::endpoint::DefaultResolver::new();
390        let endpoint = resolver.resolve_endpoint(&params);
391        let error = endpoint.expect_err("expected error: S3 MRAP does not support dual-stack [MRAP does not support DualStack]");
392        assert_eq!(format!("{}", error), "S3 MRAP does not support dual-stack")
393    }
394
395    /// MRAP does not support S3 Accelerate
396    #[test]
397    fn test_18() {
398        let params = crate::config::endpoint::Params::builder()
399            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
400            .region("us-east-1".to_string())
401            .disable_multi_region_access_points(false)
402            .use_fips(false)
403            .use_dual_stack(false)
404            .accelerate(true)
405            .build()
406            .expect("invalid params");
407        let resolver = crate::config::endpoint::DefaultResolver::new();
408        let endpoint = resolver.resolve_endpoint(&params);
409        let error = endpoint.expect_err("expected error: S3 MRAP does not support S3 Accelerate [MRAP does not support S3 Accelerate]");
410        assert_eq!(format!("{}", error), "S3 MRAP does not support S3 Accelerate")
411    }
412
413    /// MRAP explicitly disabled
414    #[test]
415    fn test_19() {
416        let params = crate::config::endpoint::Params::builder()
417            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
418            .region("us-east-1".to_string())
419            .disable_multi_region_access_points(true)
420            .use_fips(false)
421            .use_dual_stack(false)
422            .accelerate(false)
423            .build()
424            .expect("invalid params");
425        let resolver = crate::config::endpoint::DefaultResolver::new();
426        let endpoint = resolver.resolve_endpoint(&params);
427        let error =
428            endpoint.expect_err("expected error: Invalid configuration: Multi-Region Access Point ARNs are disabled. [MRAP explicitly disabled]");
429        assert_eq!(
430            format!("{}", error),
431            "Invalid configuration: Multi-Region Access Point ARNs are disabled."
432        )
433    }
434
435    /// Dual-stack endpoint with path-style forced
436    #[test]
437    fn test_20() {
438        let params = crate::config::endpoint::Params::builder()
439            .bucket("bucketname".to_string())
440            .region("us-west-2".to_string())
441            .force_path_style(true)
442            .use_fips(false)
443            .accelerate(false)
444            .use_dual_stack(true)
445            .build()
446            .expect("invalid params");
447        let resolver = crate::config::endpoint::DefaultResolver::new();
448        let endpoint = resolver.resolve_endpoint(&params);
449        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/bucketname");
450        assert_eq!(
451            endpoint,
452            ::aws_smithy_types::endpoint::Endpoint::builder()
453                .url("https://s3.dualstack.us-west-2.amazonaws.com/bucketname")
454                .property(
455                    "authSchemes",
456                    vec![{
457                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
458                        out.insert("name".to_string(), "sigv4".to_string().into());
459                        out.insert("signingName".to_string(), "s3".to_string().into());
460                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
461                        out.insert("disableDoubleEncoding".to_string(), true.into());
462                        out
463                    }
464                    .into()]
465                )
466                .build()
467        );
468    }
469
470    /// Dual-stack endpoint + SDK::Host is error
471    #[test]
472    fn test_21() {
473        let params = crate::config::endpoint::Params::builder()
474            .bucket("bucketname".to_string())
475            .region("us-west-2".to_string())
476            .force_path_style(true)
477            .use_fips(false)
478            .accelerate(false)
479            .use_dual_stack(true)
480            .endpoint("https://abc.com".to_string())
481            .build()
482            .expect("invalid params");
483        let resolver = crate::config::endpoint::DefaultResolver::new();
484        let endpoint = resolver.resolve_endpoint(&params);
485        let error = endpoint
486            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [Dual-stack endpoint + SDK::Host is error]");
487        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
488    }
489
490    /// path style + ARN bucket
491    #[test]
492    fn test_22() {
493        let params = crate::config::endpoint::Params::builder()
494            .accelerate(false)
495            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
496            .force_path_style(true)
497            .region("us-west-2".to_string())
498            .use_dual_stack(false)
499            .use_fips(false)
500            .build()
501            .expect("invalid params");
502        let resolver = crate::config::endpoint::DefaultResolver::new();
503        let endpoint = resolver.resolve_endpoint(&params);
504        let error = endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + ARN bucket]");
505        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
506    }
507
508    /// implicit path style bucket + dualstack
509    #[test]
510    fn test_23() {
511        let params = crate::config::endpoint::Params::builder()
512            .accelerate(false)
513            .bucket("99_ab".to_string())
514            .region("us-west-2".to_string())
515            .use_dual_stack(true)
516            .use_fips(false)
517            .build()
518            .expect("invalid params");
519        let resolver = crate::config::endpoint::DefaultResolver::new();
520        let endpoint = resolver.resolve_endpoint(&params);
521        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/99_ab");
522        assert_eq!(
523            endpoint,
524            ::aws_smithy_types::endpoint::Endpoint::builder()
525                .url("https://s3.dualstack.us-west-2.amazonaws.com/99_ab")
526                .property(
527                    "authSchemes",
528                    vec![{
529                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
530                        out.insert("name".to_string(), "sigv4".to_string().into());
531                        out.insert("signingName".to_string(), "s3".to_string().into());
532                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
533                        out.insert("disableDoubleEncoding".to_string(), true.into());
534                        out
535                    }
536                    .into()]
537                )
538                .build()
539        );
540    }
541
542    /// implicit path style bucket + dualstack
543    #[test]
544    fn test_24() {
545        let params = crate::config::endpoint::Params::builder()
546            .accelerate(false)
547            .bucket("99_ab".to_string())
548            .region("us-west-2".to_string())
549            .use_dual_stack(true)
550            .use_fips(false)
551            .endpoint("http://abc.com".to_string())
552            .build()
553            .expect("invalid params");
554        let resolver = crate::config::endpoint::DefaultResolver::new();
555        let endpoint = resolver.resolve_endpoint(&params);
556        let error = endpoint
557            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [implicit path style bucket + dualstack]");
558        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
559    }
560
561    /// don't allow URL injections in the bucket
562    #[test]
563    fn test_25() {
564        let params = crate::config::endpoint::Params::builder()
565            .bucket("example.com#".to_string())
566            .region("us-west-2".to_string())
567            .use_dual_stack(false)
568            .use_fips(false)
569            .accelerate(false)
570            .build()
571            .expect("invalid params");
572        let resolver = crate::config::endpoint::DefaultResolver::new();
573        let endpoint = resolver.resolve_endpoint(&params);
574        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/example.com%23");
575        assert_eq!(
576            endpoint,
577            ::aws_smithy_types::endpoint::Endpoint::builder()
578                .url("https://s3.us-west-2.amazonaws.com/example.com%23")
579                .property(
580                    "authSchemes",
581                    vec![{
582                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
583                        out.insert("name".to_string(), "sigv4".to_string().into());
584                        out.insert("signingName".to_string(), "s3".to_string().into());
585                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
586                        out.insert("disableDoubleEncoding".to_string(), true.into());
587                        out
588                    }
589                    .into()]
590                )
591                .build()
592        );
593    }
594
595    /// URI encode bucket names in the path
596    #[test]
597    fn test_26() {
598        let params = crate::config::endpoint::Params::builder()
599            .bucket("bucket name".to_string())
600            .region("us-west-2".to_string())
601            .use_dual_stack(false)
602            .use_fips(false)
603            .accelerate(false)
604            .build()
605            .expect("invalid params");
606        let resolver = crate::config::endpoint::DefaultResolver::new();
607        let endpoint = resolver.resolve_endpoint(&params);
608        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket%20name");
609        assert_eq!(
610            endpoint,
611            ::aws_smithy_types::endpoint::Endpoint::builder()
612                .url("https://s3.us-west-2.amazonaws.com/bucket%20name")
613                .property(
614                    "authSchemes",
615                    vec![{
616                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
617                        out.insert("name".to_string(), "sigv4".to_string().into());
618                        out.insert("signingName".to_string(), "s3".to_string().into());
619                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
620                        out.insert("disableDoubleEncoding".to_string(), true.into());
621                        out
622                    }
623                    .into()]
624                )
625                .build()
626        );
627    }
628
629    /// scheme is respected
630    #[test]
631    fn test_27() {
632        let params = crate::config::endpoint::Params::builder()
633            .accelerate(false)
634            .bucket("99_ab".to_string())
635            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
636            .region("af-south-1".to_string())
637            .use_dual_stack(false)
638            .use_fips(false)
639            .build()
640            .expect("invalid params");
641        let resolver = crate::config::endpoint::DefaultResolver::new();
642        let endpoint = resolver.resolve_endpoint(&params);
643        let endpoint = endpoint.expect("Expected valid endpoint: http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab");
644        assert_eq!(
645            endpoint,
646            ::aws_smithy_types::endpoint::Endpoint::builder()
647                .url("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab")
648                .property(
649                    "authSchemes",
650                    vec![{
651                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
652                        out.insert("name".to_string(), "sigv4".to_string().into());
653                        out.insert("signingName".to_string(), "s3".to_string().into());
654                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
655                        out.insert("disableDoubleEncoding".to_string(), true.into());
656                        out
657                    }
658                    .into()]
659                )
660                .build()
661        );
662    }
663
664    /// scheme is respected (virtual addressing)
665    #[test]
666    fn test_28() {
667        let params = crate::config::endpoint::Params::builder()
668            .accelerate(false)
669            .bucket("bucketname".to_string())
670            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo".to_string())
671            .region("af-south-1".to_string())
672            .use_dual_stack(false)
673            .use_fips(false)
674            .build()
675            .expect("invalid params");
676        let resolver = crate::config::endpoint::DefaultResolver::new();
677        let endpoint = resolver.resolve_endpoint(&params);
678        let endpoint = endpoint.expect("Expected valid endpoint: http://bucketname.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo");
679        assert_eq!(
680            endpoint,
681            ::aws_smithy_types::endpoint::Endpoint::builder()
682                .url("http://bucketname.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo")
683                .property(
684                    "authSchemes",
685                    vec![{
686                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
687                        out.insert("name".to_string(), "sigv4".to_string().into());
688                        out.insert("signingName".to_string(), "s3".to_string().into());
689                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
690                        out.insert("disableDoubleEncoding".to_string(), true.into());
691                        out
692                    }
693                    .into()]
694                )
695                .build()
696        );
697    }
698
699    /// path style + implicit private link
700    #[test]
701    fn test_29() {
702        let params = crate::config::endpoint::Params::builder()
703            .accelerate(false)
704            .bucket("99_ab".to_string())
705            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
706            .region("af-south-1".to_string())
707            .use_dual_stack(false)
708            .use_fips(false)
709            .build()
710            .expect("invalid params");
711        let resolver = crate::config::endpoint::DefaultResolver::new();
712        let endpoint = resolver.resolve_endpoint(&params);
713        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab");
714        assert_eq!(
715            endpoint,
716            ::aws_smithy_types::endpoint::Endpoint::builder()
717                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab")
718                .property(
719                    "authSchemes",
720                    vec![{
721                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
722                        out.insert("name".to_string(), "sigv4".to_string().into());
723                        out.insert("signingName".to_string(), "s3".to_string().into());
724                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
725                        out.insert("disableDoubleEncoding".to_string(), true.into());
726                        out
727                    }
728                    .into()]
729                )
730                .build()
731        );
732    }
733
734    /// invalid Endpoint override
735    #[test]
736    fn test_30() {
737        let params = crate::config::endpoint::Params::builder()
738            .accelerate(false)
739            .bucket("bucketname".to_string())
740            .endpoint("abcde://nota#url".to_string())
741            .region("af-south-1".to_string())
742            .use_dual_stack(false)
743            .use_fips(false)
744            .build()
745            .expect("invalid params");
746        let resolver = crate::config::endpoint::DefaultResolver::new();
747        let endpoint = resolver.resolve_endpoint(&params);
748        let error = endpoint.expect_err("expected error: Custom endpoint `abcde://nota#url` was not a valid URI [invalid Endpoint override]");
749        assert_eq!(format!("{}", error), "Custom endpoint `abcde://nota#url` was not a valid URI")
750    }
751
752    /// using an IPv4 address forces path style
753    #[test]
754    fn test_31() {
755        let params = crate::config::endpoint::Params::builder()
756            .accelerate(false)
757            .bucket("bucketname".to_string())
758            .endpoint("https://123.123.0.1".to_string())
759            .region("af-south-1".to_string())
760            .use_dual_stack(false)
761            .use_fips(false)
762            .build()
763            .expect("invalid params");
764        let resolver = crate::config::endpoint::DefaultResolver::new();
765        let endpoint = resolver.resolve_endpoint(&params);
766        let endpoint = endpoint.expect("Expected valid endpoint: https://123.123.0.1/bucketname");
767        assert_eq!(
768            endpoint,
769            ::aws_smithy_types::endpoint::Endpoint::builder()
770                .url("https://123.123.0.1/bucketname")
771                .property(
772                    "authSchemes",
773                    vec![{
774                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
775                        out.insert("name".to_string(), "sigv4".to_string().into());
776                        out.insert("signingName".to_string(), "s3".to_string().into());
777                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
778                        out.insert("disableDoubleEncoding".to_string(), true.into());
779                        out
780                    }
781                    .into()]
782                )
783                .build()
784        );
785    }
786
787    /// vanilla access point arn with region mismatch and UseArnRegion=false
788    #[test]
789    fn test_32() {
790        let params = crate::config::endpoint::Params::builder()
791            .accelerate(false)
792            .bucket("arn:aws:s3:us-east-1:123456789012:accesspoint:myendpoint".to_string())
793            .force_path_style(false)
794            .use_arn_region(false)
795            .region("us-west-2".to_string())
796            .use_dual_stack(false)
797            .use_fips(false)
798            .build()
799            .expect("invalid params");
800        let resolver = crate::config::endpoint::DefaultResolver::new();
801        let endpoint = resolver.resolve_endpoint(&params);
802        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]");
803        assert_eq!(
804            format!("{}", error),
805            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
806        )
807    }
808
809    /// vanilla access point arn with region mismatch and UseArnRegion unset
810    #[test]
811    fn test_33() {
812        let params = crate::config::endpoint::Params::builder()
813            .accelerate(false)
814            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
815            .force_path_style(false)
816            .region("us-east-1".to_string())
817            .use_dual_stack(false)
818            .use_fips(false)
819            .build()
820            .expect("invalid params");
821        let resolver = crate::config::endpoint::DefaultResolver::new();
822        let endpoint = resolver.resolve_endpoint(&params);
823        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
824        assert_eq!(
825            endpoint,
826            ::aws_smithy_types::endpoint::Endpoint::builder()
827                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
828                .property(
829                    "authSchemes",
830                    vec![{
831                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
832                        out.insert("name".to_string(), "sigv4".to_string().into());
833                        out.insert("signingName".to_string(), "s3".to_string().into());
834                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
835                        out.insert("disableDoubleEncoding".to_string(), true.into());
836                        out
837                    }
838                    .into()]
839                )
840                .build()
841        );
842    }
843
844    /// vanilla access point arn with region mismatch and UseArnRegion=true
845    #[test]
846    fn test_34() {
847        let params = crate::config::endpoint::Params::builder()
848            .accelerate(false)
849            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
850            .force_path_style(false)
851            .use_arn_region(true)
852            .region("us-east-1".to_string())
853            .use_dual_stack(false)
854            .use_fips(false)
855            .build()
856            .expect("invalid params");
857        let resolver = crate::config::endpoint::DefaultResolver::new();
858        let endpoint = resolver.resolve_endpoint(&params);
859        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
860        assert_eq!(
861            endpoint,
862            ::aws_smithy_types::endpoint::Endpoint::builder()
863                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
864                .property(
865                    "authSchemes",
866                    vec![{
867                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
868                        out.insert("name".to_string(), "sigv4".to_string().into());
869                        out.insert("signingName".to_string(), "s3".to_string().into());
870                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
871                        out.insert("disableDoubleEncoding".to_string(), true.into());
872                        out
873                    }
874                    .into()]
875                )
876                .build()
877        );
878    }
879
880    /// subdomains are not allowed in virtual buckets
881    #[test]
882    fn test_35() {
883        let params = crate::config::endpoint::Params::builder()
884            .bucket("bucket.name".to_string())
885            .region("us-east-1".to_string())
886            .build()
887            .expect("invalid params");
888        let resolver = crate::config::endpoint::DefaultResolver::new();
889        let endpoint = resolver.resolve_endpoint(&params);
890        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/bucket.name");
891        assert_eq!(
892            endpoint,
893            ::aws_smithy_types::endpoint::Endpoint::builder()
894                .url("https://s3.us-east-1.amazonaws.com/bucket.name")
895                .property(
896                    "authSchemes",
897                    vec![{
898                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
899                        out.insert("name".to_string(), "sigv4".to_string().into());
900                        out.insert("signingName".to_string(), "s3".to_string().into());
901                        out.insert("disableDoubleEncoding".to_string(), true.into());
902                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
903                        out
904                    }
905                    .into()]
906                )
907                .build()
908        );
909    }
910
911    /// bucket names with 3 characters are allowed in virtual buckets
912    #[test]
913    fn test_36() {
914        let params = crate::config::endpoint::Params::builder()
915            .bucket("aaa".to_string())
916            .region("us-east-1".to_string())
917            .build()
918            .expect("invalid params");
919        let resolver = crate::config::endpoint::DefaultResolver::new();
920        let endpoint = resolver.resolve_endpoint(&params);
921        let endpoint = endpoint.expect("Expected valid endpoint: https://aaa.s3.us-east-1.amazonaws.com");
922        assert_eq!(
923            endpoint,
924            ::aws_smithy_types::endpoint::Endpoint::builder()
925                .url("https://aaa.s3.us-east-1.amazonaws.com")
926                .property(
927                    "authSchemes",
928                    vec![{
929                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
930                        out.insert("name".to_string(), "sigv4".to_string().into());
931                        out.insert("signingName".to_string(), "s3".to_string().into());
932                        out.insert("disableDoubleEncoding".to_string(), true.into());
933                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
934                        out
935                    }
936                    .into()]
937                )
938                .build()
939        );
940    }
941
942    /// bucket names with fewer than 3 characters are not allowed in virtual host
943    #[test]
944    fn test_37() {
945        let params = crate::config::endpoint::Params::builder()
946            .bucket("aa".to_string())
947            .region("us-east-1".to_string())
948            .build()
949            .expect("invalid params");
950        let resolver = crate::config::endpoint::DefaultResolver::new();
951        let endpoint = resolver.resolve_endpoint(&params);
952        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/aa");
953        assert_eq!(
954            endpoint,
955            ::aws_smithy_types::endpoint::Endpoint::builder()
956                .url("https://s3.us-east-1.amazonaws.com/aa")
957                .property(
958                    "authSchemes",
959                    vec![{
960                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
961                        out.insert("name".to_string(), "sigv4".to_string().into());
962                        out.insert("signingName".to_string(), "s3".to_string().into());
963                        out.insert("disableDoubleEncoding".to_string(), true.into());
964                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
965                        out
966                    }
967                    .into()]
968                )
969                .build()
970        );
971    }
972
973    /// bucket names with uppercase characters are not allowed in virtual host
974    #[test]
975    fn test_38() {
976        let params = crate::config::endpoint::Params::builder()
977            .bucket("BucketName".to_string())
978            .region("us-east-1".to_string())
979            .build()
980            .expect("invalid params");
981        let resolver = crate::config::endpoint::DefaultResolver::new();
982        let endpoint = resolver.resolve_endpoint(&params);
983        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/BucketName");
984        assert_eq!(
985            endpoint,
986            ::aws_smithy_types::endpoint::Endpoint::builder()
987                .url("https://s3.us-east-1.amazonaws.com/BucketName")
988                .property(
989                    "authSchemes",
990                    vec![{
991                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
992                        out.insert("name".to_string(), "sigv4".to_string().into());
993                        out.insert("signingName".to_string(), "s3".to_string().into());
994                        out.insert("disableDoubleEncoding".to_string(), true.into());
995                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
996                        out
997                    }
998                    .into()]
999                )
1000                .build()
1001        );
1002    }
1003
1004    /// subdomains are allowed in virtual buckets on http endpoints
1005    #[test]
1006    fn test_39() {
1007        let params = crate::config::endpoint::Params::builder()
1008            .bucket("bucket.name".to_string())
1009            .region("us-east-1".to_string())
1010            .endpoint("http://example.com".to_string())
1011            .build()
1012            .expect("invalid params");
1013        let resolver = crate::config::endpoint::DefaultResolver::new();
1014        let endpoint = resolver.resolve_endpoint(&params);
1015        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket.name.example.com");
1016        assert_eq!(
1017            endpoint,
1018            ::aws_smithy_types::endpoint::Endpoint::builder()
1019                .url("http://bucket.name.example.com")
1020                .property(
1021                    "authSchemes",
1022                    vec![{
1023                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1024                        out.insert("name".to_string(), "sigv4".to_string().into());
1025                        out.insert("signingName".to_string(), "s3".to_string().into());
1026                        out.insert("disableDoubleEncoding".to_string(), true.into());
1027                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1028                        out
1029                    }
1030                    .into()]
1031                )
1032                .build()
1033        );
1034    }
1035
1036    /// no region set
1037    #[test]
1038    fn test_40() {
1039        let params = crate::config::endpoint::Params::builder()
1040            .bucket("bucket-name".to_string())
1041            .build()
1042            .expect("invalid params");
1043        let resolver = crate::config::endpoint::DefaultResolver::new();
1044        let endpoint = resolver.resolve_endpoint(&params);
1045        let error = endpoint.expect_err("expected error: A region must be set when sending requests to S3. [no region set]");
1046        assert_eq!(format!("{}", error), "A region must be set when sending requests to S3.")
1047    }
1048
1049    /// UseGlobalEndpoints=true, region=us-east-1 uses the global endpoint
1050    #[test]
1051    fn test_41() {
1052        let params = crate::config::endpoint::Params::builder()
1053            .region("us-east-1".to_string())
1054            .use_global_endpoint(true)
1055            .use_fips(false)
1056            .use_dual_stack(false)
1057            .accelerate(false)
1058            .build()
1059            .expect("invalid params");
1060        let resolver = crate::config::endpoint::DefaultResolver::new();
1061        let endpoint = resolver.resolve_endpoint(&params);
1062        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1063        assert_eq!(
1064            endpoint,
1065            ::aws_smithy_types::endpoint::Endpoint::builder()
1066                .url("https://s3.amazonaws.com")
1067                .property(
1068                    "authSchemes",
1069                    vec![{
1070                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1071                        out.insert("name".to_string(), "sigv4".to_string().into());
1072                        out.insert("signingName".to_string(), "s3".to_string().into());
1073                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1074                        out.insert("disableDoubleEncoding".to_string(), true.into());
1075                        out
1076                    }
1077                    .into()]
1078                )
1079                .build()
1080        );
1081    }
1082
1083    /// UseGlobalEndpoints=true, region=us-west-2 uses the regional endpoint
1084    #[test]
1085    fn test_42() {
1086        let params = crate::config::endpoint::Params::builder()
1087            .region("us-west-2".to_string())
1088            .use_global_endpoint(true)
1089            .use_fips(false)
1090            .use_dual_stack(false)
1091            .accelerate(false)
1092            .build()
1093            .expect("invalid params");
1094        let resolver = crate::config::endpoint::DefaultResolver::new();
1095        let endpoint = resolver.resolve_endpoint(&params);
1096        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com");
1097        assert_eq!(
1098            endpoint,
1099            ::aws_smithy_types::endpoint::Endpoint::builder()
1100                .url("https://s3.us-west-2.amazonaws.com")
1101                .property(
1102                    "authSchemes",
1103                    vec![{
1104                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1105                        out.insert("name".to_string(), "sigv4".to_string().into());
1106                        out.insert("signingName".to_string(), "s3".to_string().into());
1107                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
1108                        out.insert("disableDoubleEncoding".to_string(), true.into());
1109                        out
1110                    }
1111                    .into()]
1112                )
1113                .build()
1114        );
1115    }
1116
1117    /// UseGlobalEndpoints=true, region=cn-north-1 uses the regional endpoint
1118    #[test]
1119    fn test_43() {
1120        let params = crate::config::endpoint::Params::builder()
1121            .region("cn-north-1".to_string())
1122            .use_global_endpoint(true)
1123            .use_fips(false)
1124            .use_dual_stack(false)
1125            .accelerate(false)
1126            .build()
1127            .expect("invalid params");
1128        let resolver = crate::config::endpoint::DefaultResolver::new();
1129        let endpoint = resolver.resolve_endpoint(&params);
1130        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn");
1131        assert_eq!(
1132            endpoint,
1133            ::aws_smithy_types::endpoint::Endpoint::builder()
1134                .url("https://s3.cn-north-1.amazonaws.com.cn")
1135                .property(
1136                    "authSchemes",
1137                    vec![{
1138                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1139                        out.insert("name".to_string(), "sigv4".to_string().into());
1140                        out.insert("signingName".to_string(), "s3".to_string().into());
1141                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
1142                        out.insert("disableDoubleEncoding".to_string(), true.into());
1143                        out
1144                    }
1145                    .into()]
1146                )
1147                .build()
1148        );
1149    }
1150
1151    /// UseGlobalEndpoints=true, region=us-east-1, fips=true uses the regional endpoint with fips
1152    #[test]
1153    fn test_44() {
1154        let params = crate::config::endpoint::Params::builder()
1155            .region("us-east-1".to_string())
1156            .use_global_endpoint(true)
1157            .use_fips(true)
1158            .use_dual_stack(false)
1159            .accelerate(false)
1160            .build()
1161            .expect("invalid params");
1162        let resolver = crate::config::endpoint::DefaultResolver::new();
1163        let endpoint = resolver.resolve_endpoint(&params);
1164        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com");
1165        assert_eq!(
1166            endpoint,
1167            ::aws_smithy_types::endpoint::Endpoint::builder()
1168                .url("https://s3-fips.us-east-1.amazonaws.com")
1169                .property(
1170                    "authSchemes",
1171                    vec![{
1172                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1173                        out.insert("name".to_string(), "sigv4".to_string().into());
1174                        out.insert("signingName".to_string(), "s3".to_string().into());
1175                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1176                        out.insert("disableDoubleEncoding".to_string(), true.into());
1177                        out
1178                    }
1179                    .into()]
1180                )
1181                .build()
1182        );
1183    }
1184
1185    /// UseGlobalEndpoints=true, region=us-east-1, dualstack=true uses the regional endpoint with dualstack
1186    #[test]
1187    fn test_45() {
1188        let params = crate::config::endpoint::Params::builder()
1189            .region("us-east-1".to_string())
1190            .use_global_endpoint(true)
1191            .use_fips(false)
1192            .use_dual_stack(true)
1193            .accelerate(false)
1194            .build()
1195            .expect("invalid params");
1196        let resolver = crate::config::endpoint::DefaultResolver::new();
1197        let endpoint = resolver.resolve_endpoint(&params);
1198        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com");
1199        assert_eq!(
1200            endpoint,
1201            ::aws_smithy_types::endpoint::Endpoint::builder()
1202                .url("https://s3.dualstack.us-east-1.amazonaws.com")
1203                .property(
1204                    "authSchemes",
1205                    vec![{
1206                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1207                        out.insert("name".to_string(), "sigv4".to_string().into());
1208                        out.insert("signingName".to_string(), "s3".to_string().into());
1209                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1210                        out.insert("disableDoubleEncoding".to_string(), true.into());
1211                        out
1212                    }
1213                    .into()]
1214                )
1215                .build()
1216        );
1217    }
1218
1219    /// UseGlobalEndpoints=true, region=us-east-1, dualstack and fips uses the regional endpoint with fips/dualstack
1220    #[test]
1221    fn test_46() {
1222        let params = crate::config::endpoint::Params::builder()
1223            .region("us-east-1".to_string())
1224            .use_global_endpoint(true)
1225            .use_fips(true)
1226            .use_dual_stack(true)
1227            .accelerate(false)
1228            .build()
1229            .expect("invalid params");
1230        let resolver = crate::config::endpoint::DefaultResolver::new();
1231        let endpoint = resolver.resolve_endpoint(&params);
1232        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com");
1233        assert_eq!(
1234            endpoint,
1235            ::aws_smithy_types::endpoint::Endpoint::builder()
1236                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com")
1237                .property(
1238                    "authSchemes",
1239                    vec![{
1240                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1241                        out.insert("name".to_string(), "sigv4".to_string().into());
1242                        out.insert("signingName".to_string(), "s3".to_string().into());
1243                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1244                        out.insert("disableDoubleEncoding".to_string(), true.into());
1245                        out
1246                    }
1247                    .into()]
1248                )
1249                .build()
1250        );
1251    }
1252
1253    /// UseGlobalEndpoints=true, region=us-east-1 with custom endpoint, uses custom
1254    #[test]
1255    fn test_47() {
1256        let params = crate::config::endpoint::Params::builder()
1257            .region("us-east-1".to_string())
1258            .endpoint("https://example.com".to_string())
1259            .use_global_endpoint(true)
1260            .use_fips(false)
1261            .use_dual_stack(false)
1262            .accelerate(false)
1263            .build()
1264            .expect("invalid params");
1265        let resolver = crate::config::endpoint::DefaultResolver::new();
1266        let endpoint = resolver.resolve_endpoint(&params);
1267        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1268        assert_eq!(
1269            endpoint,
1270            ::aws_smithy_types::endpoint::Endpoint::builder()
1271                .url("https://example.com")
1272                .property(
1273                    "authSchemes",
1274                    vec![{
1275                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1276                        out.insert("name".to_string(), "sigv4".to_string().into());
1277                        out.insert("signingName".to_string(), "s3".to_string().into());
1278                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1279                        out.insert("disableDoubleEncoding".to_string(), true.into());
1280                        out
1281                    }
1282                    .into()]
1283                )
1284                .build()
1285        );
1286    }
1287
1288    /// UseGlobalEndpoints=true, region=us-west-2 with custom endpoint, uses custom
1289    #[test]
1290    fn test_48() {
1291        let params = crate::config::endpoint::Params::builder()
1292            .region("us-west-2".to_string())
1293            .endpoint("https://example.com".to_string())
1294            .use_global_endpoint(true)
1295            .use_fips(false)
1296            .use_dual_stack(false)
1297            .accelerate(false)
1298            .build()
1299            .expect("invalid params");
1300        let resolver = crate::config::endpoint::DefaultResolver::new();
1301        let endpoint = resolver.resolve_endpoint(&params);
1302        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1303        assert_eq!(
1304            endpoint,
1305            ::aws_smithy_types::endpoint::Endpoint::builder()
1306                .url("https://example.com")
1307                .property(
1308                    "authSchemes",
1309                    vec![{
1310                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1311                        out.insert("name".to_string(), "sigv4".to_string().into());
1312                        out.insert("signingName".to_string(), "s3".to_string().into());
1313                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
1314                        out.insert("disableDoubleEncoding".to_string(), true.into());
1315                        out
1316                    }
1317                    .into()]
1318                )
1319                .build()
1320        );
1321    }
1322
1323    /// UseGlobalEndpoints=true, region=us-east-1 with accelerate on non bucket case uses the global endpoint and ignores accelerate
1324    #[test]
1325    fn test_49() {
1326        let params = crate::config::endpoint::Params::builder()
1327            .region("us-east-1".to_string())
1328            .use_global_endpoint(true)
1329            .use_fips(false)
1330            .use_dual_stack(false)
1331            .accelerate(true)
1332            .build()
1333            .expect("invalid params");
1334        let resolver = crate::config::endpoint::DefaultResolver::new();
1335        let endpoint = resolver.resolve_endpoint(&params);
1336        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1337        assert_eq!(
1338            endpoint,
1339            ::aws_smithy_types::endpoint::Endpoint::builder()
1340                .url("https://s3.amazonaws.com")
1341                .property(
1342                    "authSchemes",
1343                    vec![{
1344                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1345                        out.insert("name".to_string(), "sigv4".to_string().into());
1346                        out.insert("signingName".to_string(), "s3".to_string().into());
1347                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1348                        out.insert("disableDoubleEncoding".to_string(), true.into());
1349                        out
1350                    }
1351                    .into()]
1352                )
1353                .build()
1354        );
1355    }
1356
1357    /// aws-global region uses the global endpoint
1358    #[test]
1359    fn test_50() {
1360        let params = crate::config::endpoint::Params::builder()
1361            .region("aws-global".to_string())
1362            .use_fips(false)
1363            .use_dual_stack(false)
1364            .accelerate(false)
1365            .build()
1366            .expect("invalid params");
1367        let resolver = crate::config::endpoint::DefaultResolver::new();
1368        let endpoint = resolver.resolve_endpoint(&params);
1369        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1370        assert_eq!(
1371            endpoint,
1372            ::aws_smithy_types::endpoint::Endpoint::builder()
1373                .url("https://s3.amazonaws.com")
1374                .property(
1375                    "authSchemes",
1376                    vec![{
1377                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1378                        out.insert("name".to_string(), "sigv4".to_string().into());
1379                        out.insert("signingName".to_string(), "s3".to_string().into());
1380                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1381                        out.insert("disableDoubleEncoding".to_string(), true.into());
1382                        out
1383                    }
1384                    .into()]
1385                )
1386                .build()
1387        );
1388    }
1389
1390    /// aws-global region with fips uses the regional endpoint
1391    #[test]
1392    fn test_51() {
1393        let params = crate::config::endpoint::Params::builder()
1394            .region("aws-global".to_string())
1395            .use_fips(true)
1396            .use_dual_stack(false)
1397            .accelerate(false)
1398            .build()
1399            .expect("invalid params");
1400        let resolver = crate::config::endpoint::DefaultResolver::new();
1401        let endpoint = resolver.resolve_endpoint(&params);
1402        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com");
1403        assert_eq!(
1404            endpoint,
1405            ::aws_smithy_types::endpoint::Endpoint::builder()
1406                .url("https://s3-fips.us-east-1.amazonaws.com")
1407                .property(
1408                    "authSchemes",
1409                    vec![{
1410                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1411                        out.insert("name".to_string(), "sigv4".to_string().into());
1412                        out.insert("signingName".to_string(), "s3".to_string().into());
1413                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1414                        out.insert("disableDoubleEncoding".to_string(), true.into());
1415                        out
1416                    }
1417                    .into()]
1418                )
1419                .build()
1420        );
1421    }
1422
1423    /// aws-global region with dualstack uses the regional endpoint
1424    #[test]
1425    fn test_52() {
1426        let params = crate::config::endpoint::Params::builder()
1427            .region("aws-global".to_string())
1428            .use_fips(false)
1429            .use_dual_stack(true)
1430            .accelerate(false)
1431            .build()
1432            .expect("invalid params");
1433        let resolver = crate::config::endpoint::DefaultResolver::new();
1434        let endpoint = resolver.resolve_endpoint(&params);
1435        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com");
1436        assert_eq!(
1437            endpoint,
1438            ::aws_smithy_types::endpoint::Endpoint::builder()
1439                .url("https://s3.dualstack.us-east-1.amazonaws.com")
1440                .property(
1441                    "authSchemes",
1442                    vec![{
1443                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1444                        out.insert("name".to_string(), "sigv4".to_string().into());
1445                        out.insert("signingName".to_string(), "s3".to_string().into());
1446                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1447                        out.insert("disableDoubleEncoding".to_string(), true.into());
1448                        out
1449                    }
1450                    .into()]
1451                )
1452                .build()
1453        );
1454    }
1455
1456    /// aws-global region with fips and dualstack uses the regional endpoint
1457    #[test]
1458    fn test_53() {
1459        let params = crate::config::endpoint::Params::builder()
1460            .region("aws-global".to_string())
1461            .use_fips(true)
1462            .use_dual_stack(true)
1463            .accelerate(false)
1464            .build()
1465            .expect("invalid params");
1466        let resolver = crate::config::endpoint::DefaultResolver::new();
1467        let endpoint = resolver.resolve_endpoint(&params);
1468        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com");
1469        assert_eq!(
1470            endpoint,
1471            ::aws_smithy_types::endpoint::Endpoint::builder()
1472                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com")
1473                .property(
1474                    "authSchemes",
1475                    vec![{
1476                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1477                        out.insert("name".to_string(), "sigv4".to_string().into());
1478                        out.insert("signingName".to_string(), "s3".to_string().into());
1479                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1480                        out.insert("disableDoubleEncoding".to_string(), true.into());
1481                        out
1482                    }
1483                    .into()]
1484                )
1485                .build()
1486        );
1487    }
1488
1489    /// aws-global region with accelerate on non-bucket case, uses global endpoint and ignores accelerate
1490    #[test]
1491    fn test_54() {
1492        let params = crate::config::endpoint::Params::builder()
1493            .region("aws-global".to_string())
1494            .use_fips(false)
1495            .use_dual_stack(false)
1496            .accelerate(true)
1497            .build()
1498            .expect("invalid params");
1499        let resolver = crate::config::endpoint::DefaultResolver::new();
1500        let endpoint = resolver.resolve_endpoint(&params);
1501        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1502        assert_eq!(
1503            endpoint,
1504            ::aws_smithy_types::endpoint::Endpoint::builder()
1505                .url("https://s3.amazonaws.com")
1506                .property(
1507                    "authSchemes",
1508                    vec![{
1509                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1510                        out.insert("name".to_string(), "sigv4".to_string().into());
1511                        out.insert("signingName".to_string(), "s3".to_string().into());
1512                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1513                        out.insert("disableDoubleEncoding".to_string(), true.into());
1514                        out
1515                    }
1516                    .into()]
1517                )
1518                .build()
1519        );
1520    }
1521
1522    /// aws-global region with custom endpoint, uses custom
1523    #[test]
1524    fn test_55() {
1525        let params = crate::config::endpoint::Params::builder()
1526            .region("aws-global".to_string())
1527            .endpoint("https://example.com".to_string())
1528            .use_global_endpoint(false)
1529            .use_fips(false)
1530            .use_dual_stack(false)
1531            .accelerate(false)
1532            .build()
1533            .expect("invalid params");
1534        let resolver = crate::config::endpoint::DefaultResolver::new();
1535        let endpoint = resolver.resolve_endpoint(&params);
1536        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1537        assert_eq!(
1538            endpoint,
1539            ::aws_smithy_types::endpoint::Endpoint::builder()
1540                .url("https://example.com")
1541                .property(
1542                    "authSchemes",
1543                    vec![{
1544                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1545                        out.insert("name".to_string(), "sigv4".to_string().into());
1546                        out.insert("signingName".to_string(), "s3".to_string().into());
1547                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1548                        out.insert("disableDoubleEncoding".to_string(), true.into());
1549                        out
1550                    }
1551                    .into()]
1552                )
1553                .build()
1554        );
1555    }
1556
1557    /// virtual addressing, aws-global region uses the global endpoint
1558    #[test]
1559    fn test_56() {
1560        let params = crate::config::endpoint::Params::builder()
1561            .region("aws-global".to_string())
1562            .bucket("bucket-name".to_string())
1563            .use_fips(false)
1564            .use_dual_stack(false)
1565            .accelerate(false)
1566            .build()
1567            .expect("invalid params");
1568        let resolver = crate::config::endpoint::DefaultResolver::new();
1569        let endpoint = resolver.resolve_endpoint(&params);
1570        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1571        assert_eq!(
1572            endpoint,
1573            ::aws_smithy_types::endpoint::Endpoint::builder()
1574                .url("https://bucket-name.s3.amazonaws.com")
1575                .property(
1576                    "authSchemes",
1577                    vec![{
1578                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1579                        out.insert("name".to_string(), "sigv4".to_string().into());
1580                        out.insert("signingName".to_string(), "s3".to_string().into());
1581                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1582                        out.insert("disableDoubleEncoding".to_string(), true.into());
1583                        out
1584                    }
1585                    .into()]
1586                )
1587                .build()
1588        );
1589    }
1590
1591    /// virtual addressing, aws-global region with Prefix, and Key uses the global endpoint. Prefix and Key parameters should not be used in endpoint evaluation.
1592    #[test]
1593    fn test_57() {
1594        let params = crate::config::endpoint::Params::builder()
1595            .region("aws-global".to_string())
1596            .bucket("bucket-name".to_string())
1597            .use_fips(false)
1598            .use_dual_stack(false)
1599            .accelerate(false)
1600            .prefix("prefix".to_string())
1601            .key("key".to_string())
1602            .build()
1603            .expect("invalid params");
1604        let resolver = crate::config::endpoint::DefaultResolver::new();
1605        let endpoint = resolver.resolve_endpoint(&params);
1606        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1607        assert_eq!(
1608            endpoint,
1609            ::aws_smithy_types::endpoint::Endpoint::builder()
1610                .url("https://bucket-name.s3.amazonaws.com")
1611                .property(
1612                    "authSchemes",
1613                    vec![{
1614                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1615                        out.insert("name".to_string(), "sigv4".to_string().into());
1616                        out.insert("signingName".to_string(), "s3".to_string().into());
1617                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1618                        out.insert("disableDoubleEncoding".to_string(), true.into());
1619                        out
1620                    }
1621                    .into()]
1622                )
1623                .build()
1624        );
1625    }
1626
1627    /// 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.
1628    #[test]
1629    fn test_58() {
1630        let params = crate::config::endpoint::Params::builder()
1631            .region("aws-global".to_string())
1632            .bucket("bucket-name".to_string())
1633            .use_fips(false)
1634            .use_dual_stack(false)
1635            .accelerate(false)
1636            .copy_source("/copy/source".to_string())
1637            .key("key".to_string())
1638            .build()
1639            .expect("invalid params");
1640        let resolver = crate::config::endpoint::DefaultResolver::new();
1641        let endpoint = resolver.resolve_endpoint(&params);
1642        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1643        assert_eq!(
1644            endpoint,
1645            ::aws_smithy_types::endpoint::Endpoint::builder()
1646                .url("https://bucket-name.s3.amazonaws.com")
1647                .property(
1648                    "authSchemes",
1649                    vec![{
1650                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1651                        out.insert("name".to_string(), "sigv4".to_string().into());
1652                        out.insert("signingName".to_string(), "s3".to_string().into());
1653                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1654                        out.insert("disableDoubleEncoding".to_string(), true.into());
1655                        out
1656                    }
1657                    .into()]
1658                )
1659                .build()
1660        );
1661    }
1662
1663    /// virtual addressing, aws-global region with fips uses the regional fips endpoint
1664    #[test]
1665    fn test_59() {
1666        let params = crate::config::endpoint::Params::builder()
1667            .region("aws-global".to_string())
1668            .bucket("bucket-name".to_string())
1669            .use_fips(true)
1670            .use_dual_stack(false)
1671            .accelerate(false)
1672            .build()
1673            .expect("invalid params");
1674        let resolver = crate::config::endpoint::DefaultResolver::new();
1675        let endpoint = resolver.resolve_endpoint(&params);
1676        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-east-1.amazonaws.com");
1677        assert_eq!(
1678            endpoint,
1679            ::aws_smithy_types::endpoint::Endpoint::builder()
1680                .url("https://bucket-name.s3-fips.us-east-1.amazonaws.com")
1681                .property(
1682                    "authSchemes",
1683                    vec![{
1684                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1685                        out.insert("name".to_string(), "sigv4".to_string().into());
1686                        out.insert("signingName".to_string(), "s3".to_string().into());
1687                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1688                        out.insert("disableDoubleEncoding".to_string(), true.into());
1689                        out
1690                    }
1691                    .into()]
1692                )
1693                .build()
1694        );
1695    }
1696
1697    /// virtual addressing, aws-global region with dualstack uses the regional dualstack endpoint
1698    #[test]
1699    fn test_60() {
1700        let params = crate::config::endpoint::Params::builder()
1701            .region("aws-global".to_string())
1702            .bucket("bucket-name".to_string())
1703            .use_fips(false)
1704            .use_dual_stack(true)
1705            .accelerate(false)
1706            .build()
1707            .expect("invalid params");
1708        let resolver = crate::config::endpoint::DefaultResolver::new();
1709        let endpoint = resolver.resolve_endpoint(&params);
1710        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-east-1.amazonaws.com");
1711        assert_eq!(
1712            endpoint,
1713            ::aws_smithy_types::endpoint::Endpoint::builder()
1714                .url("https://bucket-name.s3.dualstack.us-east-1.amazonaws.com")
1715                .property(
1716                    "authSchemes",
1717                    vec![{
1718                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1719                        out.insert("name".to_string(), "sigv4".to_string().into());
1720                        out.insert("signingName".to_string(), "s3".to_string().into());
1721                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1722                        out.insert("disableDoubleEncoding".to_string(), true.into());
1723                        out
1724                    }
1725                    .into()]
1726                )
1727                .build()
1728        );
1729    }
1730
1731    /// virtual addressing, aws-global region with fips/dualstack uses the regional fips/dualstack endpoint
1732    #[test]
1733    fn test_61() {
1734        let params = crate::config::endpoint::Params::builder()
1735            .region("aws-global".to_string())
1736            .bucket("bucket-name".to_string())
1737            .use_fips(true)
1738            .use_dual_stack(true)
1739            .accelerate(false)
1740            .build()
1741            .expect("invalid params");
1742        let resolver = crate::config::endpoint::DefaultResolver::new();
1743        let endpoint = resolver.resolve_endpoint(&params);
1744        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.us-east-1.amazonaws.com");
1745        assert_eq!(
1746            endpoint,
1747            ::aws_smithy_types::endpoint::Endpoint::builder()
1748                .url("https://bucket-name.s3-fips.dualstack.us-east-1.amazonaws.com")
1749                .property(
1750                    "authSchemes",
1751                    vec![{
1752                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1753                        out.insert("name".to_string(), "sigv4".to_string().into());
1754                        out.insert("signingName".to_string(), "s3".to_string().into());
1755                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1756                        out.insert("disableDoubleEncoding".to_string(), true.into());
1757                        out
1758                    }
1759                    .into()]
1760                )
1761                .build()
1762        );
1763    }
1764
1765    /// virtual addressing, aws-global region with accelerate uses the global accelerate endpoint
1766    #[test]
1767    fn test_62() {
1768        let params = crate::config::endpoint::Params::builder()
1769            .region("aws-global".to_string())
1770            .bucket("bucket-name".to_string())
1771            .use_fips(false)
1772            .use_dual_stack(false)
1773            .accelerate(true)
1774            .build()
1775            .expect("invalid params");
1776        let resolver = crate::config::endpoint::DefaultResolver::new();
1777        let endpoint = resolver.resolve_endpoint(&params);
1778        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
1779        assert_eq!(
1780            endpoint,
1781            ::aws_smithy_types::endpoint::Endpoint::builder()
1782                .url("https://bucket-name.s3-accelerate.amazonaws.com")
1783                .property(
1784                    "authSchemes",
1785                    vec![{
1786                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1787                        out.insert("name".to_string(), "sigv4".to_string().into());
1788                        out.insert("signingName".to_string(), "s3".to_string().into());
1789                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1790                        out.insert("disableDoubleEncoding".to_string(), true.into());
1791                        out
1792                    }
1793                    .into()]
1794                )
1795                .build()
1796        );
1797    }
1798
1799    /// virtual addressing, aws-global region with custom endpoint
1800    #[test]
1801    fn test_63() {
1802        let params = crate::config::endpoint::Params::builder()
1803            .region("aws-global".to_string())
1804            .endpoint("https://example.com".to_string())
1805            .bucket("bucket-name".to_string())
1806            .use_fips(false)
1807            .use_dual_stack(false)
1808            .accelerate(false)
1809            .build()
1810            .expect("invalid params");
1811        let resolver = crate::config::endpoint::DefaultResolver::new();
1812        let endpoint = resolver.resolve_endpoint(&params);
1813        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.example.com");
1814        assert_eq!(
1815            endpoint,
1816            ::aws_smithy_types::endpoint::Endpoint::builder()
1817                .url("https://bucket-name.example.com")
1818                .property(
1819                    "authSchemes",
1820                    vec![{
1821                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1822                        out.insert("name".to_string(), "sigv4".to_string().into());
1823                        out.insert("signingName".to_string(), "s3".to_string().into());
1824                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1825                        out.insert("disableDoubleEncoding".to_string(), true.into());
1826                        out
1827                    }
1828                    .into()]
1829                )
1830                .build()
1831        );
1832    }
1833
1834    /// virtual addressing, UseGlobalEndpoint and us-east-1 region uses the global endpoint
1835    #[test]
1836    fn test_64() {
1837        let params = crate::config::endpoint::Params::builder()
1838            .region("us-east-1".to_string())
1839            .use_global_endpoint(true)
1840            .bucket("bucket-name".to_string())
1841            .use_fips(false)
1842            .use_dual_stack(false)
1843            .accelerate(false)
1844            .build()
1845            .expect("invalid params");
1846        let resolver = crate::config::endpoint::DefaultResolver::new();
1847        let endpoint = resolver.resolve_endpoint(&params);
1848        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1849        assert_eq!(
1850            endpoint,
1851            ::aws_smithy_types::endpoint::Endpoint::builder()
1852                .url("https://bucket-name.s3.amazonaws.com")
1853                .property(
1854                    "authSchemes",
1855                    vec![{
1856                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1857                        out.insert("name".to_string(), "sigv4".to_string().into());
1858                        out.insert("signingName".to_string(), "s3".to_string().into());
1859                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1860                        out.insert("disableDoubleEncoding".to_string(), true.into());
1861                        out
1862                    }
1863                    .into()]
1864                )
1865                .build()
1866        );
1867    }
1868
1869    /// virtual addressing, UseGlobalEndpoint and us-west-2 region uses the regional endpoint
1870    #[test]
1871    fn test_65() {
1872        let params = crate::config::endpoint::Params::builder()
1873            .region("us-west-2".to_string())
1874            .use_global_endpoint(true)
1875            .bucket("bucket-name".to_string())
1876            .use_fips(false)
1877            .use_dual_stack(false)
1878            .accelerate(false)
1879            .build()
1880            .expect("invalid params");
1881        let resolver = crate::config::endpoint::DefaultResolver::new();
1882        let endpoint = resolver.resolve_endpoint(&params);
1883        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.us-west-2.amazonaws.com");
1884        assert_eq!(
1885            endpoint,
1886            ::aws_smithy_types::endpoint::Endpoint::builder()
1887                .url("https://bucket-name.s3.us-west-2.amazonaws.com")
1888                .property(
1889                    "authSchemes",
1890                    vec![{
1891                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1892                        out.insert("name".to_string(), "sigv4".to_string().into());
1893                        out.insert("signingName".to_string(), "s3".to_string().into());
1894                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
1895                        out.insert("disableDoubleEncoding".to_string(), true.into());
1896                        out
1897                    }
1898                    .into()]
1899                )
1900                .build()
1901        );
1902    }
1903
1904    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and fips uses the regional fips endpoint
1905    #[test]
1906    fn test_66() {
1907        let params = crate::config::endpoint::Params::builder()
1908            .region("us-east-1".to_string())
1909            .use_global_endpoint(true)
1910            .bucket("bucket-name".to_string())
1911            .use_fips(true)
1912            .use_dual_stack(false)
1913            .accelerate(false)
1914            .build()
1915            .expect("invalid params");
1916        let resolver = crate::config::endpoint::DefaultResolver::new();
1917        let endpoint = resolver.resolve_endpoint(&params);
1918        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-east-1.amazonaws.com");
1919        assert_eq!(
1920            endpoint,
1921            ::aws_smithy_types::endpoint::Endpoint::builder()
1922                .url("https://bucket-name.s3-fips.us-east-1.amazonaws.com")
1923                .property(
1924                    "authSchemes",
1925                    vec![{
1926                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1927                        out.insert("name".to_string(), "sigv4".to_string().into());
1928                        out.insert("signingName".to_string(), "s3".to_string().into());
1929                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1930                        out.insert("disableDoubleEncoding".to_string(), true.into());
1931                        out
1932                    }
1933                    .into()]
1934                )
1935                .build()
1936        );
1937    }
1938
1939    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and dualstack uses the regional dualstack endpoint
1940    #[test]
1941    fn test_67() {
1942        let params = crate::config::endpoint::Params::builder()
1943            .region("us-east-1".to_string())
1944            .use_global_endpoint(true)
1945            .bucket("bucket-name".to_string())
1946            .use_fips(false)
1947            .use_dual_stack(true)
1948            .accelerate(false)
1949            .build()
1950            .expect("invalid params");
1951        let resolver = crate::config::endpoint::DefaultResolver::new();
1952        let endpoint = resolver.resolve_endpoint(&params);
1953        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-east-1.amazonaws.com");
1954        assert_eq!(
1955            endpoint,
1956            ::aws_smithy_types::endpoint::Endpoint::builder()
1957                .url("https://bucket-name.s3.dualstack.us-east-1.amazonaws.com")
1958                .property(
1959                    "authSchemes",
1960                    vec![{
1961                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1962                        out.insert("name".to_string(), "sigv4".to_string().into());
1963                        out.insert("signingName".to_string(), "s3".to_string().into());
1964                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1965                        out.insert("disableDoubleEncoding".to_string(), true.into());
1966                        out
1967                    }
1968                    .into()]
1969                )
1970                .build()
1971        );
1972    }
1973
1974    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and accelerate uses the global accelerate endpoint
1975    #[test]
1976    fn test_68() {
1977        let params = crate::config::endpoint::Params::builder()
1978            .region("us-east-1".to_string())
1979            .use_global_endpoint(true)
1980            .bucket("bucket-name".to_string())
1981            .use_fips(false)
1982            .use_dual_stack(false)
1983            .accelerate(true)
1984            .build()
1985            .expect("invalid params");
1986        let resolver = crate::config::endpoint::DefaultResolver::new();
1987        let endpoint = resolver.resolve_endpoint(&params);
1988        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
1989        assert_eq!(
1990            endpoint,
1991            ::aws_smithy_types::endpoint::Endpoint::builder()
1992                .url("https://bucket-name.s3-accelerate.amazonaws.com")
1993                .property(
1994                    "authSchemes",
1995                    vec![{
1996                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1997                        out.insert("name".to_string(), "sigv4".to_string().into());
1998                        out.insert("signingName".to_string(), "s3".to_string().into());
1999                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2000                        out.insert("disableDoubleEncoding".to_string(), true.into());
2001                        out
2002                    }
2003                    .into()]
2004                )
2005                .build()
2006        );
2007    }
2008
2009    /// virtual addressing, UseGlobalEndpoint and us-east-1 region with custom endpoint
2010    #[test]
2011    fn test_69() {
2012        let params = crate::config::endpoint::Params::builder()
2013            .region("us-east-1".to_string())
2014            .endpoint("https://example.com".to_string())
2015            .use_global_endpoint(true)
2016            .bucket("bucket-name".to_string())
2017            .use_fips(false)
2018            .use_dual_stack(false)
2019            .accelerate(false)
2020            .build()
2021            .expect("invalid params");
2022        let resolver = crate::config::endpoint::DefaultResolver::new();
2023        let endpoint = resolver.resolve_endpoint(&params);
2024        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.example.com");
2025        assert_eq!(
2026            endpoint,
2027            ::aws_smithy_types::endpoint::Endpoint::builder()
2028                .url("https://bucket-name.example.com")
2029                .property(
2030                    "authSchemes",
2031                    vec![{
2032                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2033                        out.insert("name".to_string(), "sigv4".to_string().into());
2034                        out.insert("signingName".to_string(), "s3".to_string().into());
2035                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2036                        out.insert("disableDoubleEncoding".to_string(), true.into());
2037                        out
2038                    }
2039                    .into()]
2040                )
2041                .build()
2042        );
2043    }
2044
2045    /// ForcePathStyle, aws-global region uses the global endpoint
2046    #[test]
2047    fn test_70() {
2048        let params = crate::config::endpoint::Params::builder()
2049            .region("aws-global".to_string())
2050            .bucket("bucket-name".to_string())
2051            .force_path_style(true)
2052            .use_fips(false)
2053            .use_dual_stack(false)
2054            .accelerate(false)
2055            .build()
2056            .expect("invalid params");
2057        let resolver = crate::config::endpoint::DefaultResolver::new();
2058        let endpoint = resolver.resolve_endpoint(&params);
2059        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket-name");
2060        assert_eq!(
2061            endpoint,
2062            ::aws_smithy_types::endpoint::Endpoint::builder()
2063                .url("https://s3.amazonaws.com/bucket-name")
2064                .property(
2065                    "authSchemes",
2066                    vec![{
2067                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2068                        out.insert("name".to_string(), "sigv4".to_string().into());
2069                        out.insert("signingName".to_string(), "s3".to_string().into());
2070                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2071                        out.insert("disableDoubleEncoding".to_string(), true.into());
2072                        out
2073                    }
2074                    .into()]
2075                )
2076                .build()
2077        );
2078    }
2079
2080    /// ForcePathStyle, aws-global region with fips is invalid
2081    #[test]
2082    fn test_71() {
2083        let params = crate::config::endpoint::Params::builder()
2084            .region("aws-global".to_string())
2085            .bucket("bucket-name".to_string())
2086            .force_path_style(true)
2087            .use_fips(true)
2088            .use_dual_stack(false)
2089            .accelerate(false)
2090            .build()
2091            .expect("invalid params");
2092        let resolver = crate::config::endpoint::DefaultResolver::new();
2093        let endpoint = resolver.resolve_endpoint(&params);
2094        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket-name");
2095        assert_eq!(
2096            endpoint,
2097            ::aws_smithy_types::endpoint::Endpoint::builder()
2098                .url("https://s3-fips.us-east-1.amazonaws.com/bucket-name")
2099                .property(
2100                    "authSchemes",
2101                    vec![{
2102                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2103                        out.insert("signingName".to_string(), "s3".to_string().into());
2104                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2105                        out.insert("disableDoubleEncoding".to_string(), true.into());
2106                        out.insert("name".to_string(), "sigv4".to_string().into());
2107                        out
2108                    }
2109                    .into()]
2110                )
2111                .build()
2112        );
2113    }
2114
2115    /// ForcePathStyle, aws-global region with dualstack uses regional dualstack endpoint
2116    #[test]
2117    fn test_72() {
2118        let params = crate::config::endpoint::Params::builder()
2119            .region("aws-global".to_string())
2120            .bucket("bucket-name".to_string())
2121            .force_path_style(true)
2122            .use_fips(false)
2123            .use_dual_stack(true)
2124            .accelerate(false)
2125            .build()
2126            .expect("invalid params");
2127        let resolver = crate::config::endpoint::DefaultResolver::new();
2128        let endpoint = resolver.resolve_endpoint(&params);
2129        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket-name");
2130        assert_eq!(
2131            endpoint,
2132            ::aws_smithy_types::endpoint::Endpoint::builder()
2133                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket-name")
2134                .property(
2135                    "authSchemes",
2136                    vec![{
2137                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2138                        out.insert("name".to_string(), "sigv4".to_string().into());
2139                        out.insert("signingName".to_string(), "s3".to_string().into());
2140                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2141                        out.insert("disableDoubleEncoding".to_string(), true.into());
2142                        out
2143                    }
2144                    .into()]
2145                )
2146                .build()
2147        );
2148    }
2149
2150    /// ForcePathStyle, aws-global region custom endpoint uses the custom endpoint
2151    #[test]
2152    fn test_73() {
2153        let params = crate::config::endpoint::Params::builder()
2154            .region("aws-global".to_string())
2155            .endpoint("https://example.com".to_string())
2156            .bucket("bucket-name".to_string())
2157            .force_path_style(true)
2158            .use_fips(false)
2159            .use_dual_stack(false)
2160            .accelerate(false)
2161            .build()
2162            .expect("invalid params");
2163        let resolver = crate::config::endpoint::DefaultResolver::new();
2164        let endpoint = resolver.resolve_endpoint(&params);
2165        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com/bucket-name");
2166        assert_eq!(
2167            endpoint,
2168            ::aws_smithy_types::endpoint::Endpoint::builder()
2169                .url("https://example.com/bucket-name")
2170                .property(
2171                    "authSchemes",
2172                    vec![{
2173                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2174                        out.insert("name".to_string(), "sigv4".to_string().into());
2175                        out.insert("signingName".to_string(), "s3".to_string().into());
2176                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2177                        out.insert("disableDoubleEncoding".to_string(), true.into());
2178                        out
2179                    }
2180                    .into()]
2181                )
2182                .build()
2183        );
2184    }
2185
2186    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region uses the global endpoint
2187    #[test]
2188    fn test_74() {
2189        let params = crate::config::endpoint::Params::builder()
2190            .region("us-east-1".to_string())
2191            .bucket("bucket-name".to_string())
2192            .use_global_endpoint(true)
2193            .force_path_style(true)
2194            .use_fips(false)
2195            .use_dual_stack(false)
2196            .accelerate(false)
2197            .build()
2198            .expect("invalid params");
2199        let resolver = crate::config::endpoint::DefaultResolver::new();
2200        let endpoint = resolver.resolve_endpoint(&params);
2201        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket-name");
2202        assert_eq!(
2203            endpoint,
2204            ::aws_smithy_types::endpoint::Endpoint::builder()
2205                .url("https://s3.amazonaws.com/bucket-name")
2206                .property(
2207                    "authSchemes",
2208                    vec![{
2209                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2210                        out.insert("name".to_string(), "sigv4".to_string().into());
2211                        out.insert("signingName".to_string(), "s3".to_string().into());
2212                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2213                        out.insert("disableDoubleEncoding".to_string(), true.into());
2214                        out
2215                    }
2216                    .into()]
2217                )
2218                .build()
2219        );
2220    }
2221
2222    /// ForcePathStyle, UseGlobalEndpoint us-west-2 region uses the regional endpoint
2223    #[test]
2224    fn test_75() {
2225        let params = crate::config::endpoint::Params::builder()
2226            .region("us-west-2".to_string())
2227            .bucket("bucket-name".to_string())
2228            .use_global_endpoint(true)
2229            .force_path_style(true)
2230            .use_fips(false)
2231            .use_dual_stack(false)
2232            .accelerate(false)
2233            .build()
2234            .expect("invalid params");
2235        let resolver = crate::config::endpoint::DefaultResolver::new();
2236        let endpoint = resolver.resolve_endpoint(&params);
2237        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket-name");
2238        assert_eq!(
2239            endpoint,
2240            ::aws_smithy_types::endpoint::Endpoint::builder()
2241                .url("https://s3.us-west-2.amazonaws.com/bucket-name")
2242                .property(
2243                    "authSchemes",
2244                    vec![{
2245                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2246                        out.insert("name".to_string(), "sigv4".to_string().into());
2247                        out.insert("signingName".to_string(), "s3".to_string().into());
2248                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2249                        out.insert("disableDoubleEncoding".to_string(), true.into());
2250                        out
2251                    }
2252                    .into()]
2253                )
2254                .build()
2255        );
2256    }
2257
2258    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region, dualstack uses the regional dualstack endpoint
2259    #[test]
2260    fn test_76() {
2261        let params = crate::config::endpoint::Params::builder()
2262            .region("us-east-1".to_string())
2263            .bucket("bucket-name".to_string())
2264            .use_global_endpoint(true)
2265            .force_path_style(true)
2266            .use_fips(false)
2267            .use_dual_stack(true)
2268            .accelerate(false)
2269            .build()
2270            .expect("invalid params");
2271        let resolver = crate::config::endpoint::DefaultResolver::new();
2272        let endpoint = resolver.resolve_endpoint(&params);
2273        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket-name");
2274        assert_eq!(
2275            endpoint,
2276            ::aws_smithy_types::endpoint::Endpoint::builder()
2277                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket-name")
2278                .property(
2279                    "authSchemes",
2280                    vec![{
2281                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2282                        out.insert("name".to_string(), "sigv4".to_string().into());
2283                        out.insert("signingName".to_string(), "s3".to_string().into());
2284                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2285                        out.insert("disableDoubleEncoding".to_string(), true.into());
2286                        out
2287                    }
2288                    .into()]
2289                )
2290                .build()
2291        );
2292    }
2293
2294    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region custom endpoint uses the custom endpoint
2295    #[test]
2296    fn test_77() {
2297        let params = crate::config::endpoint::Params::builder()
2298            .region("us-east-1".to_string())
2299            .bucket("bucket-name".to_string())
2300            .endpoint("https://example.com".to_string())
2301            .use_global_endpoint(true)
2302            .force_path_style(true)
2303            .use_fips(false)
2304            .use_dual_stack(false)
2305            .accelerate(false)
2306            .build()
2307            .expect("invalid params");
2308        let resolver = crate::config::endpoint::DefaultResolver::new();
2309        let endpoint = resolver.resolve_endpoint(&params);
2310        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com/bucket-name");
2311        assert_eq!(
2312            endpoint,
2313            ::aws_smithy_types::endpoint::Endpoint::builder()
2314                .url("https://example.com/bucket-name")
2315                .property(
2316                    "authSchemes",
2317                    vec![{
2318                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2319                        out.insert("name".to_string(), "sigv4".to_string().into());
2320                        out.insert("signingName".to_string(), "s3".to_string().into());
2321                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2322                        out.insert("disableDoubleEncoding".to_string(), true.into());
2323                        out
2324                    }
2325                    .into()]
2326                )
2327                .build()
2328        );
2329    }
2330
2331    /// ARN with aws-global region and  UseArnRegion uses the regional endpoint
2332    #[test]
2333    fn test_78() {
2334        let params = crate::config::endpoint::Params::builder()
2335            .region("aws-global".to_string())
2336            .use_arn_region(true)
2337            .use_fips(false)
2338            .use_dual_stack(false)
2339            .accelerate(false)
2340            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
2341            .build()
2342            .expect("invalid params");
2343        let resolver = crate::config::endpoint::DefaultResolver::new();
2344        let endpoint = resolver.resolve_endpoint(&params);
2345        let endpoint =
2346            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
2347        assert_eq!(
2348            endpoint,
2349            ::aws_smithy_types::endpoint::Endpoint::builder()
2350                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
2351                .property(
2352                    "authSchemes",
2353                    vec![
2354                        {
2355                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2356                            out.insert("name".to_string(), "sigv4a".to_string().into());
2357                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
2358                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
2359                            out.insert("disableDoubleEncoding".to_string(), true.into());
2360                            out
2361                        }
2362                        .into(),
2363                        {
2364                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2365                            out.insert("name".to_string(), "sigv4".to_string().into());
2366                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
2367                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2368                            out.insert("disableDoubleEncoding".to_string(), true.into());
2369                            out
2370                        }
2371                        .into()
2372                    ]
2373                )
2374                .build()
2375        );
2376    }
2377
2378    /// cross partition MRAP ARN is an error
2379    #[test]
2380    fn test_79() {
2381        let params = crate::config::endpoint::Params::builder()
2382            .bucket("arn:aws-cn:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
2383            .region("us-west-1".to_string())
2384            .build()
2385            .expect("invalid params");
2386        let resolver = crate::config::endpoint::DefaultResolver::new();
2387        let endpoint = resolver.resolve_endpoint(&params);
2388        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]");
2389        assert_eq!(
2390            format!("{}", error),
2391            "Client was configured for partition `aws` but bucket referred to partition `aws-cn`"
2392        )
2393    }
2394
2395    /// Endpoint override, accesspoint with HTTP, port
2396    #[test]
2397    fn test_80() {
2398        let params = crate::config::endpoint::Params::builder()
2399            .endpoint("http://beta.example.com:1234".to_string())
2400            .region("us-west-2".to_string())
2401            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
2402            .build()
2403            .expect("invalid params");
2404        let resolver = crate::config::endpoint::DefaultResolver::new();
2405        let endpoint = resolver.resolve_endpoint(&params);
2406        let endpoint = endpoint.expect("Expected valid endpoint: http://myendpoint-123456789012.beta.example.com:1234");
2407        assert_eq!(
2408            endpoint,
2409            ::aws_smithy_types::endpoint::Endpoint::builder()
2410                .url("http://myendpoint-123456789012.beta.example.com:1234")
2411                .property(
2412                    "authSchemes",
2413                    vec![{
2414                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2415                        out.insert("name".to_string(), "sigv4".to_string().into());
2416                        out.insert("signingName".to_string(), "s3".to_string().into());
2417                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2418                        out.insert("disableDoubleEncoding".to_string(), true.into());
2419                        out
2420                    }
2421                    .into()]
2422                )
2423                .build()
2424        );
2425    }
2426
2427    /// Endpoint override, accesspoint with http, path, query, and port
2428    #[test]
2429    fn test_81() {
2430        let params = crate::config::endpoint::Params::builder()
2431            .region("us-west-2".to_string())
2432            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
2433            .endpoint("http://beta.example.com:1234/path".to_string())
2434            .use_fips(false)
2435            .use_dual_stack(false)
2436            .accelerate(false)
2437            .build()
2438            .expect("invalid params");
2439        let resolver = crate::config::endpoint::DefaultResolver::new();
2440        let endpoint = resolver.resolve_endpoint(&params);
2441        let endpoint = endpoint.expect("Expected valid endpoint: http://myendpoint-123456789012.beta.example.com:1234/path");
2442        assert_eq!(
2443            endpoint,
2444            ::aws_smithy_types::endpoint::Endpoint::builder()
2445                .url("http://myendpoint-123456789012.beta.example.com:1234/path")
2446                .property(
2447                    "authSchemes",
2448                    vec![{
2449                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2450                        out.insert("name".to_string(), "sigv4".to_string().into());
2451                        out.insert("signingName".to_string(), "s3".to_string().into());
2452                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2453                        out.insert("disableDoubleEncoding".to_string(), true.into());
2454                        out
2455                    }
2456                    .into()]
2457                )
2458                .build()
2459        );
2460    }
2461
2462    /// non-bucket endpoint override with FIPS = error
2463    #[test]
2464    fn test_82() {
2465        let params = crate::config::endpoint::Params::builder()
2466            .region("us-west-2".to_string())
2467            .endpoint("http://beta.example.com:1234/path".to_string())
2468            .use_fips(true)
2469            .use_dual_stack(false)
2470            .build()
2471            .expect("invalid params");
2472        let resolver = crate::config::endpoint::DefaultResolver::new();
2473        let endpoint = resolver.resolve_endpoint(&params);
2474        let error =
2475            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [non-bucket endpoint override with FIPS = error]");
2476        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2477    }
2478
2479    /// FIPS + dualstack + custom endpoint
2480    #[test]
2481    fn test_83() {
2482        let params = crate::config::endpoint::Params::builder()
2483            .region("us-west-2".to_string())
2484            .endpoint("http://beta.example.com:1234/path".to_string())
2485            .use_fips(true)
2486            .use_dual_stack(true)
2487            .build()
2488            .expect("invalid params");
2489        let resolver = crate::config::endpoint::DefaultResolver::new();
2490        let endpoint = resolver.resolve_endpoint(&params);
2491        let error =
2492            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [FIPS + dualstack + custom endpoint]");
2493        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
2494    }
2495
2496    /// dualstack + custom endpoint
2497    #[test]
2498    fn test_84() {
2499        let params = crate::config::endpoint::Params::builder()
2500            .region("us-west-2".to_string())
2501            .endpoint("http://beta.example.com:1234/path".to_string())
2502            .use_fips(false)
2503            .use_dual_stack(true)
2504            .build()
2505            .expect("invalid params");
2506        let resolver = crate::config::endpoint::DefaultResolver::new();
2507        let endpoint = resolver.resolve_endpoint(&params);
2508        let error = endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [dualstack + custom endpoint]");
2509        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
2510    }
2511
2512    /// custom endpoint without FIPS/dualstack
2513    #[test]
2514    fn test_85() {
2515        let params = crate::config::endpoint::Params::builder()
2516            .region("us-west-2".to_string())
2517            .endpoint("http://beta.example.com:1234/path".to_string())
2518            .use_fips(false)
2519            .use_dual_stack(false)
2520            .build()
2521            .expect("invalid params");
2522        let resolver = crate::config::endpoint::DefaultResolver::new();
2523        let endpoint = resolver.resolve_endpoint(&params);
2524        let endpoint = endpoint.expect("Expected valid endpoint: http://beta.example.com:1234/path");
2525        assert_eq!(
2526            endpoint,
2527            ::aws_smithy_types::endpoint::Endpoint::builder()
2528                .url("http://beta.example.com:1234/path")
2529                .property(
2530                    "authSchemes",
2531                    vec![{
2532                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2533                        out.insert("name".to_string(), "sigv4".to_string().into());
2534                        out.insert("signingName".to_string(), "s3".to_string().into());
2535                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2536                        out.insert("disableDoubleEncoding".to_string(), true.into());
2537                        out
2538                    }
2539                    .into()]
2540                )
2541                .build()
2542        );
2543    }
2544
2545    /// s3 object lambda with access points disabled
2546    #[test]
2547    fn test_86() {
2548        let params = crate::config::endpoint::Params::builder()
2549            .region("us-west-2".to_string())
2550            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:myendpoint".to_string())
2551            .disable_access_points(true)
2552            .build()
2553            .expect("invalid params");
2554        let resolver = crate::config::endpoint::DefaultResolver::new();
2555        let endpoint = resolver.resolve_endpoint(&params);
2556        let error =
2557            endpoint.expect_err("expected error: Access points are not supported for this operation [s3 object lambda with access points disabled]");
2558        assert_eq!(format!("{}", error), "Access points are not supported for this operation")
2559    }
2560
2561    /// non bucket + FIPS
2562    #[test]
2563    fn test_87() {
2564        let params = crate::config::endpoint::Params::builder()
2565            .region("us-west-2".to_string())
2566            .use_fips(true)
2567            .use_dual_stack(false)
2568            .build()
2569            .expect("invalid params");
2570        let resolver = crate::config::endpoint::DefaultResolver::new();
2571        let endpoint = resolver.resolve_endpoint(&params);
2572        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-west-2.amazonaws.com");
2573        assert_eq!(
2574            endpoint,
2575            ::aws_smithy_types::endpoint::Endpoint::builder()
2576                .url("https://s3-fips.us-west-2.amazonaws.com")
2577                .property(
2578                    "authSchemes",
2579                    vec![{
2580                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2581                        out.insert("name".to_string(), "sigv4".to_string().into());
2582                        out.insert("signingName".to_string(), "s3".to_string().into());
2583                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2584                        out.insert("disableDoubleEncoding".to_string(), true.into());
2585                        out
2586                    }
2587                    .into()]
2588                )
2589                .build()
2590        );
2591    }
2592
2593    /// standard non bucket endpoint
2594    #[test]
2595    fn test_88() {
2596        let params = crate::config::endpoint::Params::builder()
2597            .region("us-west-2".to_string())
2598            .use_fips(false)
2599            .use_dual_stack(false)
2600            .build()
2601            .expect("invalid params");
2602        let resolver = crate::config::endpoint::DefaultResolver::new();
2603        let endpoint = resolver.resolve_endpoint(&params);
2604        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com");
2605        assert_eq!(
2606            endpoint,
2607            ::aws_smithy_types::endpoint::Endpoint::builder()
2608                .url("https://s3.us-west-2.amazonaws.com")
2609                .property(
2610                    "authSchemes",
2611                    vec![{
2612                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2613                        out.insert("name".to_string(), "sigv4".to_string().into());
2614                        out.insert("signingName".to_string(), "s3".to_string().into());
2615                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2616                        out.insert("disableDoubleEncoding".to_string(), true.into());
2617                        out
2618                    }
2619                    .into()]
2620                )
2621                .build()
2622        );
2623    }
2624
2625    /// non bucket endpoint with FIPS + Dualstack
2626    #[test]
2627    fn test_89() {
2628        let params = crate::config::endpoint::Params::builder()
2629            .region("us-west-2".to_string())
2630            .use_fips(true)
2631            .use_dual_stack(true)
2632            .build()
2633            .expect("invalid params");
2634        let resolver = crate::config::endpoint::DefaultResolver::new();
2635        let endpoint = resolver.resolve_endpoint(&params);
2636        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-west-2.amazonaws.com");
2637        assert_eq!(
2638            endpoint,
2639            ::aws_smithy_types::endpoint::Endpoint::builder()
2640                .url("https://s3-fips.dualstack.us-west-2.amazonaws.com")
2641                .property(
2642                    "authSchemes",
2643                    vec![{
2644                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2645                        out.insert("name".to_string(), "sigv4".to_string().into());
2646                        out.insert("signingName".to_string(), "s3".to_string().into());
2647                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2648                        out.insert("disableDoubleEncoding".to_string(), true.into());
2649                        out
2650                    }
2651                    .into()]
2652                )
2653                .build()
2654        );
2655    }
2656
2657    /// non bucket endpoint with dualstack
2658    #[test]
2659    fn test_90() {
2660        let params = crate::config::endpoint::Params::builder()
2661            .region("us-west-2".to_string())
2662            .use_fips(false)
2663            .use_dual_stack(true)
2664            .build()
2665            .expect("invalid params");
2666        let resolver = crate::config::endpoint::DefaultResolver::new();
2667        let endpoint = resolver.resolve_endpoint(&params);
2668        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com");
2669        assert_eq!(
2670            endpoint,
2671            ::aws_smithy_types::endpoint::Endpoint::builder()
2672                .url("https://s3.dualstack.us-west-2.amazonaws.com")
2673                .property(
2674                    "authSchemes",
2675                    vec![{
2676                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2677                        out.insert("name".to_string(), "sigv4".to_string().into());
2678                        out.insert("signingName".to_string(), "s3".to_string().into());
2679                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2680                        out.insert("disableDoubleEncoding".to_string(), true.into());
2681                        out
2682                    }
2683                    .into()]
2684                )
2685                .build()
2686        );
2687    }
2688
2689    /// use global endpoint + IP address endpoint override
2690    #[test]
2691    fn test_91() {
2692        let params = crate::config::endpoint::Params::builder()
2693            .region("us-east-1".to_string())
2694            .bucket("bucket".to_string())
2695            .use_fips(false)
2696            .use_dual_stack(false)
2697            .endpoint("http://127.0.0.1".to_string())
2698            .use_global_endpoint(true)
2699            .build()
2700            .expect("invalid params");
2701        let resolver = crate::config::endpoint::DefaultResolver::new();
2702        let endpoint = resolver.resolve_endpoint(&params);
2703        let endpoint = endpoint.expect("Expected valid endpoint: http://127.0.0.1/bucket");
2704        assert_eq!(
2705            endpoint,
2706            ::aws_smithy_types::endpoint::Endpoint::builder()
2707                .url("http://127.0.0.1/bucket")
2708                .property(
2709                    "authSchemes",
2710                    vec![{
2711                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2712                        out.insert("name".to_string(), "sigv4".to_string().into());
2713                        out.insert("signingName".to_string(), "s3".to_string().into());
2714                        out.insert("disableDoubleEncoding".to_string(), true.into());
2715                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2716                        out
2717                    }
2718                    .into()]
2719                )
2720                .build()
2721        );
2722    }
2723
2724    /// non-dns endpoint + global endpoint
2725    #[test]
2726    fn test_92() {
2727        let params = crate::config::endpoint::Params::builder()
2728            .region("us-east-1".to_string())
2729            .bucket("bucket!".to_string())
2730            .use_fips(false)
2731            .use_dual_stack(false)
2732            .use_global_endpoint(true)
2733            .build()
2734            .expect("invalid params");
2735        let resolver = crate::config::endpoint::DefaultResolver::new();
2736        let endpoint = resolver.resolve_endpoint(&params);
2737        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket%21");
2738        assert_eq!(
2739            endpoint,
2740            ::aws_smithy_types::endpoint::Endpoint::builder()
2741                .url("https://s3.amazonaws.com/bucket%21")
2742                .property(
2743                    "authSchemes",
2744                    vec![{
2745                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2746                        out.insert("name".to_string(), "sigv4".to_string().into());
2747                        out.insert("signingName".to_string(), "s3".to_string().into());
2748                        out.insert("disableDoubleEncoding".to_string(), true.into());
2749                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2750                        out
2751                    }
2752                    .into()]
2753                )
2754                .build()
2755        );
2756    }
2757
2758    /// endpoint override + use global endpoint
2759    #[test]
2760    fn test_93() {
2761        let params = crate::config::endpoint::Params::builder()
2762            .region("us-east-1".to_string())
2763            .bucket("bucket!".to_string())
2764            .use_fips(false)
2765            .use_dual_stack(false)
2766            .use_global_endpoint(true)
2767            .endpoint("http://foo.com".to_string())
2768            .build()
2769            .expect("invalid params");
2770        let resolver = crate::config::endpoint::DefaultResolver::new();
2771        let endpoint = resolver.resolve_endpoint(&params);
2772        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
2773        assert_eq!(
2774            endpoint,
2775            ::aws_smithy_types::endpoint::Endpoint::builder()
2776                .url("http://foo.com/bucket%21")
2777                .property(
2778                    "authSchemes",
2779                    vec![{
2780                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2781                        out.insert("name".to_string(), "sigv4".to_string().into());
2782                        out.insert("signingName".to_string(), "s3".to_string().into());
2783                        out.insert("disableDoubleEncoding".to_string(), true.into());
2784                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2785                        out
2786                    }
2787                    .into()]
2788                )
2789                .build()
2790        );
2791    }
2792
2793    /// FIPS + dualstack + non-bucket endpoint
2794    #[test]
2795    fn test_94() {
2796        let params = crate::config::endpoint::Params::builder()
2797            .region("us-east-1".to_string())
2798            .bucket("bucket!".to_string())
2799            .use_fips(true)
2800            .use_dual_stack(true)
2801            .build()
2802            .expect("invalid params");
2803        let resolver = crate::config::endpoint::DefaultResolver::new();
2804        let endpoint = resolver.resolve_endpoint(&params);
2805        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
2806        assert_eq!(
2807            endpoint,
2808            ::aws_smithy_types::endpoint::Endpoint::builder()
2809                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
2810                .property(
2811                    "authSchemes",
2812                    vec![{
2813                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2814                        out.insert("name".to_string(), "sigv4".to_string().into());
2815                        out.insert("signingName".to_string(), "s3".to_string().into());
2816                        out.insert("disableDoubleEncoding".to_string(), true.into());
2817                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2818                        out
2819                    }
2820                    .into()]
2821                )
2822                .build()
2823        );
2824    }
2825
2826    /// FIPS + dualstack + non-DNS endpoint
2827    #[test]
2828    fn test_95() {
2829        let params = crate::config::endpoint::Params::builder()
2830            .region("us-east-1".to_string())
2831            .bucket("bucket!".to_string())
2832            .force_path_style(true)
2833            .use_fips(true)
2834            .use_dual_stack(true)
2835            .build()
2836            .expect("invalid params");
2837        let resolver = crate::config::endpoint::DefaultResolver::new();
2838        let endpoint = resolver.resolve_endpoint(&params);
2839        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
2840        assert_eq!(
2841            endpoint,
2842            ::aws_smithy_types::endpoint::Endpoint::builder()
2843                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
2844                .property(
2845                    "authSchemes",
2846                    vec![{
2847                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2848                        out.insert("name".to_string(), "sigv4".to_string().into());
2849                        out.insert("signingName".to_string(), "s3".to_string().into());
2850                        out.insert("disableDoubleEncoding".to_string(), true.into());
2851                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2852                        out
2853                    }
2854                    .into()]
2855                )
2856                .build()
2857        );
2858    }
2859
2860    /// endpoint override + FIPS + dualstack (BUG)
2861    #[test]
2862    fn test_96() {
2863        let params = crate::config::endpoint::Params::builder()
2864            .region("us-east-1".to_string())
2865            .bucket("bucket!".to_string())
2866            .force_path_style(true)
2867            .use_fips(true)
2868            .use_dual_stack(false)
2869            .endpoint("http://foo.com".to_string())
2870            .build()
2871            .expect("invalid params");
2872        let resolver = crate::config::endpoint::DefaultResolver::new();
2873        let endpoint = resolver.resolve_endpoint(&params);
2874        let error =
2875            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [endpoint override + FIPS + dualstack (BUG)]");
2876        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2877    }
2878
2879    /// endpoint override + non-dns bucket + FIPS (BUG)
2880    #[test]
2881    fn test_97() {
2882        let params = crate::config::endpoint::Params::builder()
2883            .region("us-east-1".to_string())
2884            .bucket("bucket!".to_string())
2885            .use_fips(true)
2886            .use_dual_stack(false)
2887            .endpoint("http://foo.com".to_string())
2888            .build()
2889            .expect("invalid params");
2890        let resolver = crate::config::endpoint::DefaultResolver::new();
2891        let endpoint = resolver.resolve_endpoint(&params);
2892        let error =
2893            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [endpoint override + non-dns bucket + FIPS (BUG)]");
2894        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2895    }
2896
2897    /// FIPS + bucket endpoint + force path style
2898    #[test]
2899    fn test_98() {
2900        let params = crate::config::endpoint::Params::builder()
2901            .region("us-east-1".to_string())
2902            .bucket("bucket!".to_string())
2903            .force_path_style(true)
2904            .use_fips(true)
2905            .use_dual_stack(false)
2906            .use_global_endpoint(true)
2907            .build()
2908            .expect("invalid params");
2909        let resolver = crate::config::endpoint::DefaultResolver::new();
2910        let endpoint = resolver.resolve_endpoint(&params);
2911        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
2912        assert_eq!(
2913            endpoint,
2914            ::aws_smithy_types::endpoint::Endpoint::builder()
2915                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
2916                .property(
2917                    "authSchemes",
2918                    vec![{
2919                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2920                        out.insert("name".to_string(), "sigv4".to_string().into());
2921                        out.insert("signingName".to_string(), "s3".to_string().into());
2922                        out.insert("disableDoubleEncoding".to_string(), true.into());
2923                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2924                        out
2925                    }
2926                    .into()]
2927                )
2928                .build()
2929        );
2930    }
2931
2932    /// bucket + FIPS + force path style
2933    #[test]
2934    fn test_99() {
2935        let params = crate::config::endpoint::Params::builder()
2936            .region("us-east-1".to_string())
2937            .bucket("bucket".to_string())
2938            .force_path_style(true)
2939            .use_fips(true)
2940            .use_dual_stack(true)
2941            .use_global_endpoint(true)
2942            .build()
2943            .expect("invalid params");
2944        let resolver = crate::config::endpoint::DefaultResolver::new();
2945        let endpoint = resolver.resolve_endpoint(&params);
2946        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket");
2947        assert_eq!(
2948            endpoint,
2949            ::aws_smithy_types::endpoint::Endpoint::builder()
2950                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket")
2951                .property(
2952                    "authSchemes",
2953                    vec![{
2954                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2955                        out.insert("name".to_string(), "sigv4".to_string().into());
2956                        out.insert("signingName".to_string(), "s3".to_string().into());
2957                        out.insert("disableDoubleEncoding".to_string(), true.into());
2958                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2959                        out
2960                    }
2961                    .into()]
2962                )
2963                .build()
2964        );
2965    }
2966
2967    /// FIPS + dualstack + use global endpoint
2968    #[test]
2969    fn test_100() {
2970        let params = crate::config::endpoint::Params::builder()
2971            .region("us-east-1".to_string())
2972            .bucket("bucket".to_string())
2973            .use_fips(true)
2974            .use_dual_stack(true)
2975            .use_global_endpoint(true)
2976            .build()
2977            .expect("invalid params");
2978        let resolver = crate::config::endpoint::DefaultResolver::new();
2979        let endpoint = resolver.resolve_endpoint(&params);
2980        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-fips.dualstack.us-east-1.amazonaws.com");
2981        assert_eq!(
2982            endpoint,
2983            ::aws_smithy_types::endpoint::Endpoint::builder()
2984                .url("https://bucket.s3-fips.dualstack.us-east-1.amazonaws.com")
2985                .property(
2986                    "authSchemes",
2987                    vec![{
2988                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2989                        out.insert("name".to_string(), "sigv4".to_string().into());
2990                        out.insert("signingName".to_string(), "s3".to_string().into());
2991                        out.insert("disableDoubleEncoding".to_string(), true.into());
2992                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2993                        out
2994                    }
2995                    .into()]
2996                )
2997                .build()
2998        );
2999    }
3000
3001    /// URI encoded bucket + use global endpoint
3002    #[test]
3003    fn test_101() {
3004        let params = crate::config::endpoint::Params::builder()
3005            .region("us-east-1".to_string())
3006            .bucket("bucket!".to_string())
3007            .use_fips(true)
3008            .use_dual_stack(false)
3009            .use_global_endpoint(true)
3010            .endpoint("https://foo.com".to_string())
3011            .build()
3012            .expect("invalid params");
3013        let resolver = crate::config::endpoint::DefaultResolver::new();
3014        let endpoint = resolver.resolve_endpoint(&params);
3015        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [URI encoded bucket + use global endpoint]");
3016        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3017    }
3018
3019    /// FIPS + path based endpoint
3020    #[test]
3021    fn test_102() {
3022        let params = crate::config::endpoint::Params::builder()
3023            .region("us-east-1".to_string())
3024            .bucket("bucket!".to_string())
3025            .use_fips(true)
3026            .use_dual_stack(false)
3027            .accelerate(false)
3028            .use_global_endpoint(true)
3029            .build()
3030            .expect("invalid params");
3031        let resolver = crate::config::endpoint::DefaultResolver::new();
3032        let endpoint = resolver.resolve_endpoint(&params);
3033        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
3034        assert_eq!(
3035            endpoint,
3036            ::aws_smithy_types::endpoint::Endpoint::builder()
3037                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
3038                .property(
3039                    "authSchemes",
3040                    vec![{
3041                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3042                        out.insert("name".to_string(), "sigv4".to_string().into());
3043                        out.insert("signingName".to_string(), "s3".to_string().into());
3044                        out.insert("disableDoubleEncoding".to_string(), true.into());
3045                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3046                        out
3047                    }
3048                    .into()]
3049                )
3050                .build()
3051        );
3052    }
3053
3054    /// accelerate + dualstack + global endpoint
3055    #[test]
3056    fn test_103() {
3057        let params = crate::config::endpoint::Params::builder()
3058            .region("us-east-1".to_string())
3059            .bucket("bucket".to_string())
3060            .use_fips(false)
3061            .use_dual_stack(true)
3062            .accelerate(true)
3063            .use_global_endpoint(true)
3064            .build()
3065            .expect("invalid params");
3066        let resolver = crate::config::endpoint::DefaultResolver::new();
3067        let endpoint = resolver.resolve_endpoint(&params);
3068        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.dualstack.amazonaws.com");
3069        assert_eq!(
3070            endpoint,
3071            ::aws_smithy_types::endpoint::Endpoint::builder()
3072                .url("https://bucket.s3-accelerate.dualstack.amazonaws.com")
3073                .property(
3074                    "authSchemes",
3075                    vec![{
3076                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3077                        out.insert("name".to_string(), "sigv4".to_string().into());
3078                        out.insert("signingName".to_string(), "s3".to_string().into());
3079                        out.insert("disableDoubleEncoding".to_string(), true.into());
3080                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3081                        out
3082                    }
3083                    .into()]
3084                )
3085                .build()
3086        );
3087    }
3088
3089    /// dualstack + global endpoint + non URI safe bucket
3090    #[test]
3091    fn test_104() {
3092        let params = crate::config::endpoint::Params::builder()
3093            .region("us-east-1".to_string())
3094            .bucket("bucket!".to_string())
3095            .accelerate(false)
3096            .use_dual_stack(true)
3097            .use_fips(false)
3098            .use_global_endpoint(true)
3099            .build()
3100            .expect("invalid params");
3101        let resolver = crate::config::endpoint::DefaultResolver::new();
3102        let endpoint = resolver.resolve_endpoint(&params);
3103        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket%21");
3104        assert_eq!(
3105            endpoint,
3106            ::aws_smithy_types::endpoint::Endpoint::builder()
3107                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket%21")
3108                .property(
3109                    "authSchemes",
3110                    vec![{
3111                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3112                        out.insert("name".to_string(), "sigv4".to_string().into());
3113                        out.insert("signingName".to_string(), "s3".to_string().into());
3114                        out.insert("disableDoubleEncoding".to_string(), true.into());
3115                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3116                        out
3117                    }
3118                    .into()]
3119                )
3120                .build()
3121        );
3122    }
3123
3124    /// FIPS + uri encoded bucket
3125    #[test]
3126    fn test_105() {
3127        let params = crate::config::endpoint::Params::builder()
3128            .region("us-east-1".to_string())
3129            .bucket("bucket!".to_string())
3130            .force_path_style(true)
3131            .accelerate(false)
3132            .use_dual_stack(false)
3133            .use_fips(true)
3134            .use_global_endpoint(true)
3135            .build()
3136            .expect("invalid params");
3137        let resolver = crate::config::endpoint::DefaultResolver::new();
3138        let endpoint = resolver.resolve_endpoint(&params);
3139        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
3140        assert_eq!(
3141            endpoint,
3142            ::aws_smithy_types::endpoint::Endpoint::builder()
3143                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
3144                .property(
3145                    "authSchemes",
3146                    vec![{
3147                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3148                        out.insert("name".to_string(), "sigv4".to_string().into());
3149                        out.insert("signingName".to_string(), "s3".to_string().into());
3150                        out.insert("disableDoubleEncoding".to_string(), true.into());
3151                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3152                        out
3153                    }
3154                    .into()]
3155                )
3156                .build()
3157        );
3158    }
3159
3160    /// endpoint override + non-uri safe endpoint + force path style
3161    #[test]
3162    fn test_106() {
3163        let params = crate::config::endpoint::Params::builder()
3164            .region("us-east-1".to_string())
3165            .bucket("bucket!".to_string())
3166            .force_path_style(true)
3167            .accelerate(false)
3168            .use_dual_stack(false)
3169            .use_fips(true)
3170            .endpoint("http://foo.com".to_string())
3171            .use_global_endpoint(true)
3172            .build()
3173            .expect("invalid params");
3174        let resolver = crate::config::endpoint::DefaultResolver::new();
3175        let endpoint = resolver.resolve_endpoint(&params);
3176        let error = endpoint.expect_err(
3177            "expected error: A custom endpoint cannot be combined with FIPS [endpoint override + non-uri safe endpoint + force path style]",
3178        );
3179        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3180    }
3181
3182    /// FIPS + Dualstack + global endpoint + non-dns bucket
3183    #[test]
3184    fn test_107() {
3185        let params = crate::config::endpoint::Params::builder()
3186            .region("us-east-1".to_string())
3187            .bucket("bucket!".to_string())
3188            .accelerate(false)
3189            .use_dual_stack(true)
3190            .use_fips(true)
3191            .use_global_endpoint(true)
3192            .build()
3193            .expect("invalid params");
3194        let resolver = crate::config::endpoint::DefaultResolver::new();
3195        let endpoint = resolver.resolve_endpoint(&params);
3196        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
3197        assert_eq!(
3198            endpoint,
3199            ::aws_smithy_types::endpoint::Endpoint::builder()
3200                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
3201                .property(
3202                    "authSchemes",
3203                    vec![{
3204                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3205                        out.insert("name".to_string(), "sigv4".to_string().into());
3206                        out.insert("signingName".to_string(), "s3".to_string().into());
3207                        out.insert("disableDoubleEncoding".to_string(), true.into());
3208                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3209                        out
3210                    }
3211                    .into()]
3212                )
3213                .build()
3214        );
3215    }
3216
3217    /// endpoint override + FIPS + dualstack
3218    #[test]
3219    fn test_108() {
3220        let params = crate::config::endpoint::Params::builder()
3221            .region("us-east-1".to_string())
3222            .use_dual_stack(true)
3223            .use_fips(true)
3224            .use_global_endpoint(true)
3225            .endpoint("http://foo.com".to_string())
3226            .build()
3227            .expect("invalid params");
3228        let resolver = crate::config::endpoint::DefaultResolver::new();
3229        let endpoint = resolver.resolve_endpoint(&params);
3230        let error = endpoint
3231            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [endpoint override + FIPS + dualstack]");
3232        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3233    }
3234
3235    /// non-bucket endpoint override + dualstack + global endpoint
3236    #[test]
3237    fn test_109() {
3238        let params = crate::config::endpoint::Params::builder()
3239            .region("us-east-1".to_string())
3240            .use_fips(false)
3241            .use_dual_stack(true)
3242            .use_global_endpoint(true)
3243            .endpoint("http://foo.com".to_string())
3244            .build()
3245            .expect("invalid params");
3246        let resolver = crate::config::endpoint::DefaultResolver::new();
3247        let endpoint = resolver.resolve_endpoint(&params);
3248        let error = endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [non-bucket endpoint override + dualstack + global endpoint]");
3249        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3250    }
3251
3252    /// Endpoint override + UseGlobalEndpoint + us-east-1
3253    #[test]
3254    fn test_110() {
3255        let params = crate::config::endpoint::Params::builder()
3256            .region("us-east-1".to_string())
3257            .use_fips(true)
3258            .use_dual_stack(false)
3259            .use_global_endpoint(true)
3260            .endpoint("http://foo.com".to_string())
3261            .build()
3262            .expect("invalid params");
3263        let resolver = crate::config::endpoint::DefaultResolver::new();
3264        let endpoint = resolver.resolve_endpoint(&params);
3265        let error =
3266            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [Endpoint override + UseGlobalEndpoint + us-east-1]");
3267        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3268    }
3269
3270    /// non-FIPS partition with FIPS set + custom endpoint
3271    #[test]
3272    fn test_111() {
3273        let params = crate::config::endpoint::Params::builder()
3274            .region("cn-north-1".to_string())
3275            .use_fips(true)
3276            .use_dual_stack(false)
3277            .use_global_endpoint(true)
3278            .build()
3279            .expect("invalid params");
3280        let resolver = crate::config::endpoint::DefaultResolver::new();
3281        let endpoint = resolver.resolve_endpoint(&params);
3282        let error = endpoint.expect_err("expected error: Partition does not support FIPS [non-FIPS partition with FIPS set + custom endpoint]");
3283        assert_eq!(format!("{}", error), "Partition does not support FIPS")
3284    }
3285
3286    /// aws-global signs as us-east-1
3287    #[test]
3288    fn test_112() {
3289        let params = crate::config::endpoint::Params::builder()
3290            .region("aws-global".to_string())
3291            .bucket("bucket!".to_string())
3292            .use_fips(true)
3293            .accelerate(false)
3294            .use_dual_stack(true)
3295            .build()
3296            .expect("invalid params");
3297        let resolver = crate::config::endpoint::DefaultResolver::new();
3298        let endpoint = resolver.resolve_endpoint(&params);
3299        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
3300        assert_eq!(
3301            endpoint,
3302            ::aws_smithy_types::endpoint::Endpoint::builder()
3303                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
3304                .property(
3305                    "authSchemes",
3306                    vec![{
3307                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3308                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3309                        out.insert("name".to_string(), "sigv4".to_string().into());
3310                        out.insert("signingName".to_string(), "s3".to_string().into());
3311                        out.insert("disableDoubleEncoding".to_string(), true.into());
3312                        out
3313                    }
3314                    .into()]
3315                )
3316                .build()
3317        );
3318    }
3319
3320    /// aws-global signs as us-east-1
3321    #[test]
3322    fn test_113() {
3323        let params = crate::config::endpoint::Params::builder()
3324            .region("aws-global".to_string())
3325            .bucket("bucket".to_string())
3326            .use_dual_stack(false)
3327            .use_fips(false)
3328            .accelerate(false)
3329            .endpoint("https://foo.com".to_string())
3330            .build()
3331            .expect("invalid params");
3332        let resolver = crate::config::endpoint::DefaultResolver::new();
3333        let endpoint = resolver.resolve_endpoint(&params);
3334        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.foo.com");
3335        assert_eq!(
3336            endpoint,
3337            ::aws_smithy_types::endpoint::Endpoint::builder()
3338                .url("https://bucket.foo.com")
3339                .property(
3340                    "authSchemes",
3341                    vec![{
3342                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3343                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3344                        out.insert("name".to_string(), "sigv4".to_string().into());
3345                        out.insert("signingName".to_string(), "s3".to_string().into());
3346                        out.insert("disableDoubleEncoding".to_string(), true.into());
3347                        out
3348                    }
3349                    .into()]
3350                )
3351                .build()
3352        );
3353    }
3354
3355    /// aws-global + dualstack + path-only bucket
3356    #[test]
3357    fn test_114() {
3358        let params = crate::config::endpoint::Params::builder()
3359            .region("aws-global".to_string())
3360            .bucket("bucket!".to_string())
3361            .use_dual_stack(true)
3362            .use_fips(false)
3363            .accelerate(false)
3364            .build()
3365            .expect("invalid params");
3366        let resolver = crate::config::endpoint::DefaultResolver::new();
3367        let endpoint = resolver.resolve_endpoint(&params);
3368        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket%21");
3369        assert_eq!(
3370            endpoint,
3371            ::aws_smithy_types::endpoint::Endpoint::builder()
3372                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket%21")
3373                .property(
3374                    "authSchemes",
3375                    vec![{
3376                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3377                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3378                        out.insert("name".to_string(), "sigv4".to_string().into());
3379                        out.insert("signingName".to_string(), "s3".to_string().into());
3380                        out.insert("disableDoubleEncoding".to_string(), true.into());
3381                        out
3382                    }
3383                    .into()]
3384                )
3385                .build()
3386        );
3387    }
3388
3389    /// aws-global + path-only bucket
3390    #[test]
3391    fn test_115() {
3392        let params = crate::config::endpoint::Params::builder()
3393            .region("aws-global".to_string())
3394            .bucket("bucket!".to_string())
3395            .build()
3396            .expect("invalid params");
3397        let resolver = crate::config::endpoint::DefaultResolver::new();
3398        let endpoint = resolver.resolve_endpoint(&params);
3399        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket%21");
3400        assert_eq!(
3401            endpoint,
3402            ::aws_smithy_types::endpoint::Endpoint::builder()
3403                .url("https://s3.amazonaws.com/bucket%21")
3404                .property(
3405                    "authSchemes",
3406                    vec![{
3407                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3408                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3409                        out.insert("name".to_string(), "sigv4".to_string().into());
3410                        out.insert("signingName".to_string(), "s3".to_string().into());
3411                        out.insert("disableDoubleEncoding".to_string(), true.into());
3412                        out
3413                    }
3414                    .into()]
3415                )
3416                .build()
3417        );
3418    }
3419
3420    /// aws-global + fips + custom endpoint
3421    #[test]
3422    fn test_116() {
3423        let params = crate::config::endpoint::Params::builder()
3424            .region("aws-global".to_string())
3425            .bucket("bucket!".to_string())
3426            .use_dual_stack(false)
3427            .use_fips(true)
3428            .accelerate(false)
3429            .endpoint("http://foo.com".to_string())
3430            .build()
3431            .expect("invalid params");
3432        let resolver = crate::config::endpoint::DefaultResolver::new();
3433        let endpoint = resolver.resolve_endpoint(&params);
3434        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [aws-global + fips + custom endpoint]");
3435        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3436    }
3437
3438    /// aws-global, endpoint override & path only-bucket
3439    #[test]
3440    fn test_117() {
3441        let params = crate::config::endpoint::Params::builder()
3442            .region("aws-global".to_string())
3443            .bucket("bucket!".to_string())
3444            .use_dual_stack(false)
3445            .use_fips(false)
3446            .accelerate(false)
3447            .endpoint("http://foo.com".to_string())
3448            .build()
3449            .expect("invalid params");
3450        let resolver = crate::config::endpoint::DefaultResolver::new();
3451        let endpoint = resolver.resolve_endpoint(&params);
3452        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
3453        assert_eq!(
3454            endpoint,
3455            ::aws_smithy_types::endpoint::Endpoint::builder()
3456                .url("http://foo.com/bucket%21")
3457                .property(
3458                    "authSchemes",
3459                    vec![{
3460                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3461                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3462                        out.insert("name".to_string(), "sigv4".to_string().into());
3463                        out.insert("signingName".to_string(), "s3".to_string().into());
3464                        out.insert("disableDoubleEncoding".to_string(), true.into());
3465                        out
3466                    }
3467                    .into()]
3468                )
3469                .build()
3470        );
3471    }
3472
3473    /// aws-global + dualstack + custom endpoint
3474    #[test]
3475    fn test_118() {
3476        let params = crate::config::endpoint::Params::builder()
3477            .region("aws-global".to_string())
3478            .use_dual_stack(true)
3479            .use_fips(false)
3480            .accelerate(false)
3481            .endpoint("http://foo.com".to_string())
3482            .build()
3483            .expect("invalid params");
3484        let resolver = crate::config::endpoint::DefaultResolver::new();
3485        let endpoint = resolver.resolve_endpoint(&params);
3486        let error = endpoint
3487            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [aws-global + dualstack + custom endpoint]");
3488        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3489    }
3490
3491    /// accelerate, dualstack + aws-global
3492    #[test]
3493    fn test_119() {
3494        let params = crate::config::endpoint::Params::builder()
3495            .region("aws-global".to_string())
3496            .bucket("bucket".to_string())
3497            .use_dual_stack(true)
3498            .use_fips(false)
3499            .accelerate(true)
3500            .build()
3501            .expect("invalid params");
3502        let resolver = crate::config::endpoint::DefaultResolver::new();
3503        let endpoint = resolver.resolve_endpoint(&params);
3504        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.dualstack.us-east-1.amazonaws.com");
3505        assert_eq!(
3506            endpoint,
3507            ::aws_smithy_types::endpoint::Endpoint::builder()
3508                .url("https://bucket.s3-accelerate.dualstack.us-east-1.amazonaws.com")
3509                .property(
3510                    "authSchemes",
3511                    vec![{
3512                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3513                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3514                        out.insert("name".to_string(), "sigv4".to_string().into());
3515                        out.insert("signingName".to_string(), "s3".to_string().into());
3516                        out.insert("disableDoubleEncoding".to_string(), true.into());
3517                        out
3518                    }
3519                    .into()]
3520                )
3521                .build()
3522        );
3523    }
3524
3525    /// FIPS + aws-global + path only bucket. This is not supported by S3 but we allow garbage in garbage out
3526    #[test]
3527    fn test_120() {
3528        let params = crate::config::endpoint::Params::builder()
3529            .region("aws-global".to_string())
3530            .bucket("bucket!".to_string())
3531            .force_path_style(true)
3532            .use_dual_stack(true)
3533            .use_fips(true)
3534            .accelerate(false)
3535            .build()
3536            .expect("invalid params");
3537        let resolver = crate::config::endpoint::DefaultResolver::new();
3538        let endpoint = resolver.resolve_endpoint(&params);
3539        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
3540        assert_eq!(
3541            endpoint,
3542            ::aws_smithy_types::endpoint::Endpoint::builder()
3543                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
3544                .property(
3545                    "authSchemes",
3546                    vec![{
3547                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3548                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3549                        out.insert("name".to_string(), "sigv4".to_string().into());
3550                        out.insert("signingName".to_string(), "s3".to_string().into());
3551                        out.insert("disableDoubleEncoding".to_string(), true.into());
3552                        out
3553                    }
3554                    .into()]
3555                )
3556                .build()
3557        );
3558    }
3559
3560    /// aws-global + FIPS + endpoint override.
3561    #[test]
3562    fn test_121() {
3563        let params = crate::config::endpoint::Params::builder()
3564            .region("aws-global".to_string())
3565            .use_fips(true)
3566            .endpoint("http://foo.com".to_string())
3567            .build()
3568            .expect("invalid params");
3569        let resolver = crate::config::endpoint::DefaultResolver::new();
3570        let endpoint = resolver.resolve_endpoint(&params);
3571        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [aws-global + FIPS + endpoint override.]");
3572        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3573    }
3574
3575    /// force path style, FIPS, aws-global & endpoint override
3576    #[test]
3577    fn test_122() {
3578        let params = crate::config::endpoint::Params::builder()
3579            .region("aws-global".to_string())
3580            .bucket("bucket!".to_string())
3581            .force_path_style(true)
3582            .use_fips(true)
3583            .endpoint("http://foo.com".to_string())
3584            .build()
3585            .expect("invalid params");
3586        let resolver = crate::config::endpoint::DefaultResolver::new();
3587        let endpoint = resolver.resolve_endpoint(&params);
3588        let error = endpoint
3589            .expect_err("expected error: A custom endpoint cannot be combined with FIPS [force path style, FIPS, aws-global & endpoint override]");
3590        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3591    }
3592
3593    /// ip address causes path style to be forced
3594    #[test]
3595    fn test_123() {
3596        let params = crate::config::endpoint::Params::builder()
3597            .region("aws-global".to_string())
3598            .bucket("bucket".to_string())
3599            .endpoint("http://192.168.1.1".to_string())
3600            .build()
3601            .expect("invalid params");
3602        let resolver = crate::config::endpoint::DefaultResolver::new();
3603        let endpoint = resolver.resolve_endpoint(&params);
3604        let endpoint = endpoint.expect("Expected valid endpoint: http://192.168.1.1/bucket");
3605        assert_eq!(
3606            endpoint,
3607            ::aws_smithy_types::endpoint::Endpoint::builder()
3608                .url("http://192.168.1.1/bucket")
3609                .property(
3610                    "authSchemes",
3611                    vec![{
3612                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3613                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3614                        out.insert("name".to_string(), "sigv4".to_string().into());
3615                        out.insert("signingName".to_string(), "s3".to_string().into());
3616                        out.insert("disableDoubleEncoding".to_string(), true.into());
3617                        out
3618                    }
3619                    .into()]
3620                )
3621                .build()
3622        );
3623    }
3624
3625    /// endpoint override with aws-global region
3626    #[test]
3627    fn test_124() {
3628        let params = crate::config::endpoint::Params::builder()
3629            .region("aws-global".to_string())
3630            .use_fips(true)
3631            .use_dual_stack(true)
3632            .endpoint("http://foo.com".to_string())
3633            .build()
3634            .expect("invalid params");
3635        let resolver = crate::config::endpoint::DefaultResolver::new();
3636        let endpoint = resolver.resolve_endpoint(&params);
3637        let error = endpoint
3638            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [endpoint override with aws-global region]");
3639        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3640    }
3641
3642    /// FIPS + path-only (TODO: consider making this an error)
3643    #[test]
3644    fn test_125() {
3645        let params = crate::config::endpoint::Params::builder()
3646            .region("aws-global".to_string())
3647            .bucket("bucket!".to_string())
3648            .use_fips(true)
3649            .build()
3650            .expect("invalid params");
3651        let resolver = crate::config::endpoint::DefaultResolver::new();
3652        let endpoint = resolver.resolve_endpoint(&params);
3653        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
3654        assert_eq!(
3655            endpoint,
3656            ::aws_smithy_types::endpoint::Endpoint::builder()
3657                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
3658                .property(
3659                    "authSchemes",
3660                    vec![{
3661                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3662                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3663                        out.insert("name".to_string(), "sigv4".to_string().into());
3664                        out.insert("signingName".to_string(), "s3".to_string().into());
3665                        out.insert("disableDoubleEncoding".to_string(), true.into());
3666                        out
3667                    }
3668                    .into()]
3669                )
3670                .build()
3671        );
3672    }
3673
3674    /// empty arn type
3675    #[test]
3676    fn test_126() {
3677        let params = crate::config::endpoint::Params::builder()
3678            .region("us-east-2".to_string())
3679            .bucket("arn:aws:not-s3:us-west-2:123456789012::myendpoint".to_string())
3680            .build()
3681            .expect("invalid params");
3682        let resolver = crate::config::endpoint::DefaultResolver::new();
3683        let endpoint = resolver.resolve_endpoint(&params);
3684        let error = endpoint.expect_err("expected error: Invalid ARN: No ARN type specified [empty arn type]");
3685        assert_eq!(format!("{}", error), "Invalid ARN: No ARN type specified")
3686    }
3687
3688    /// path style can't be used with accelerate
3689    #[test]
3690    fn test_127() {
3691        let params = crate::config::endpoint::Params::builder()
3692            .region("us-east-2".to_string())
3693            .bucket("bucket!".to_string())
3694            .accelerate(true)
3695            .build()
3696            .expect("invalid params");
3697        let resolver = crate::config::endpoint::DefaultResolver::new();
3698        let endpoint = resolver.resolve_endpoint(&params);
3699        let error =
3700            endpoint.expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style can't be used with accelerate]");
3701        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
3702    }
3703
3704    /// invalid region
3705    #[test]
3706    fn test_128() {
3707        let params = crate::config::endpoint::Params::builder()
3708            .region("us-east-2!".to_string())
3709            .bucket("bucket.subdomain".to_string())
3710            .endpoint("http://foo.com".to_string())
3711            .build()
3712            .expect("invalid params");
3713        let resolver = crate::config::endpoint::DefaultResolver::new();
3714        let endpoint = resolver.resolve_endpoint(&params);
3715        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [invalid region]");
3716        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
3717    }
3718
3719    /// invalid region
3720    #[test]
3721    fn test_129() {
3722        let params = crate::config::endpoint::Params::builder()
3723            .region("us-east-2!".to_string())
3724            .bucket("bucket".to_string())
3725            .endpoint("http://foo.com".to_string())
3726            .build()
3727            .expect("invalid params");
3728        let resolver = crate::config::endpoint::DefaultResolver::new();
3729        let endpoint = resolver.resolve_endpoint(&params);
3730        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [invalid region]");
3731        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
3732    }
3733
3734    /// empty arn type
3735    #[test]
3736    fn test_130() {
3737        let params = crate::config::endpoint::Params::builder()
3738            .region("us-east-2".to_string())
3739            .bucket("arn:aws:s3::123456789012:accesspoint:my_endpoint".to_string())
3740            .build()
3741            .expect("invalid params");
3742        let resolver = crate::config::endpoint::DefaultResolver::new();
3743        let endpoint = resolver.resolve_endpoint(&params);
3744        let error = endpoint.expect_err("expected error: Invalid Access Point Name [empty arn type]");
3745        assert_eq!(format!("{}", error), "Invalid Access Point Name")
3746    }
3747
3748    /// empty arn type
3749    #[test]
3750    fn test_131() {
3751        let params = crate::config::endpoint::Params::builder()
3752            .region("us-east-2".to_string())
3753            .bucket("arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint".to_string())
3754            .use_arn_region(true)
3755            .build()
3756            .expect("invalid params");
3757        let resolver = crate::config::endpoint::DefaultResolver::new();
3758        let endpoint = resolver.resolve_endpoint(&params);
3759        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]");
3760        assert_eq!(
3761            format!("{}", error),
3762            "Client was configured for partition `aws` but ARN (`arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint`) has `aws-cn`"
3763        )
3764    }
3765
3766    /// invalid arn region
3767    #[test]
3768    fn test_132() {
3769        let params = crate::config::endpoint::Params::builder()
3770            .region("us-east-2".to_string())
3771            .bucket("arn:aws:s3-object-lambda:us-east_2:123456789012:accesspoint:my-endpoint".to_string())
3772            .use_arn_region(true)
3773            .build()
3774            .expect("invalid params");
3775        let resolver = crate::config::endpoint::DefaultResolver::new();
3776        let endpoint = resolver.resolve_endpoint(&params);
3777        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-east_2` (invalid DNS name) [invalid arn region]");
3778        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-east_2` (invalid DNS name)")
3779    }
3780
3781    /// invalid ARN outpost
3782    #[test]
3783    fn test_133() {
3784        let params = crate::config::endpoint::Params::builder()
3785            .region("us-east-2".to_string())
3786            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op_01234567890123456/accesspoint/reports".to_string())
3787            .use_arn_region(true)
3788            .build()
3789            .expect("invalid params");
3790        let resolver = crate::config::endpoint::DefaultResolver::new();
3791        let endpoint = resolver.resolve_endpoint(&params);
3792        let error = endpoint.expect_err(
3793            "expected error: Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `op_01234567890123456` [invalid ARN outpost]",
3794        );
3795        assert_eq!(
3796            format!("{}", error),
3797            "Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `op_01234567890123456`"
3798        )
3799    }
3800
3801    /// invalid ARN
3802    #[test]
3803    fn test_134() {
3804        let params = crate::config::endpoint::Params::builder()
3805            .region("us-east-2".to_string())
3806            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/reports".to_string())
3807            .build()
3808            .expect("invalid params");
3809        let resolver = crate::config::endpoint::DefaultResolver::new();
3810        let endpoint = resolver.resolve_endpoint(&params);
3811        let error = endpoint.expect_err("expected error: Invalid ARN: expected an access point name [invalid ARN]");
3812        assert_eq!(format!("{}", error), "Invalid ARN: expected an access point name")
3813    }
3814
3815    /// invalid ARN
3816    #[test]
3817    fn test_135() {
3818        let params = crate::config::endpoint::Params::builder()
3819            .region("us-east-2".to_string())
3820            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456".to_string())
3821            .build()
3822            .expect("invalid params");
3823        let resolver = crate::config::endpoint::DefaultResolver::new();
3824        let endpoint = resolver.resolve_endpoint(&params);
3825        let error = endpoint.expect_err("expected error: Invalid ARN: Expected a 4-component resource [invalid ARN]");
3826        assert_eq!(format!("{}", error), "Invalid ARN: Expected a 4-component resource")
3827    }
3828
3829    /// invalid outpost type
3830    #[test]
3831    fn test_136() {
3832        let params = crate::config::endpoint::Params::builder()
3833            .region("us-east-2".to_string())
3834            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3835            .build()
3836            .expect("invalid params");
3837        let resolver = crate::config::endpoint::DefaultResolver::new();
3838        let endpoint = resolver.resolve_endpoint(&params);
3839        let error = endpoint.expect_err("expected error: Expected an outpost type `accesspoint`, found not-accesspoint [invalid outpost type]");
3840        assert_eq!(format!("{}", error), "Expected an outpost type `accesspoint`, found not-accesspoint")
3841    }
3842
3843    /// invalid outpost type
3844    #[test]
3845    fn test_137() {
3846        let params = crate::config::endpoint::Params::builder()
3847            .region("us-east-2".to_string())
3848            .bucket("arn:aws:s3-outposts:us-east_1:123456789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3849            .build()
3850            .expect("invalid params");
3851        let resolver = crate::config::endpoint::DefaultResolver::new();
3852        let endpoint = resolver.resolve_endpoint(&params);
3853        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-east_1` (invalid DNS name) [invalid outpost type]");
3854        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-east_1` (invalid DNS name)")
3855    }
3856
3857    /// invalid outpost type
3858    #[test]
3859    fn test_138() {
3860        let params = crate::config::endpoint::Params::builder()
3861            .region("us-east-2".to_string())
3862            .bucket("arn:aws:s3-outposts:us-east-1:12345_789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3863            .build()
3864            .expect("invalid params");
3865        let resolver = crate::config::endpoint::DefaultResolver::new();
3866        let endpoint = resolver.resolve_endpoint(&params);
3867        let error = endpoint.expect_err(
3868            "expected error: Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `12345_789012` [invalid outpost type]",
3869        );
3870        assert_eq!(
3871            format!("{}", error),
3872            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `12345_789012`"
3873        )
3874    }
3875
3876    /// invalid outpost type
3877    #[test]
3878    fn test_139() {
3879        let params = crate::config::endpoint::Params::builder()
3880            .region("us-east-2".to_string())
3881            .bucket("arn:aws:s3-outposts:us-east-1:12345789012:outpost".to_string())
3882            .build()
3883            .expect("invalid params");
3884        let resolver = crate::config::endpoint::DefaultResolver::new();
3885        let endpoint = resolver.resolve_endpoint(&params);
3886        let error = endpoint.expect_err("expected error: Invalid ARN: The Outpost Id was not set [invalid outpost type]");
3887        assert_eq!(format!("{}", error), "Invalid ARN: The Outpost Id was not set")
3888    }
3889
3890    /// use global endpoint virtual addressing
3891    #[test]
3892    fn test_140() {
3893        let params = crate::config::endpoint::Params::builder()
3894            .region("us-east-2".to_string())
3895            .bucket("bucket".to_string())
3896            .endpoint("http://example.com".to_string())
3897            .use_global_endpoint(true)
3898            .build()
3899            .expect("invalid params");
3900        let resolver = crate::config::endpoint::DefaultResolver::new();
3901        let endpoint = resolver.resolve_endpoint(&params);
3902        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket.example.com");
3903        assert_eq!(
3904            endpoint,
3905            ::aws_smithy_types::endpoint::Endpoint::builder()
3906                .url("http://bucket.example.com")
3907                .property(
3908                    "authSchemes",
3909                    vec![{
3910                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3911                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3912                        out.insert("name".to_string(), "sigv4".to_string().into());
3913                        out.insert("signingName".to_string(), "s3".to_string().into());
3914                        out.insert("disableDoubleEncoding".to_string(), true.into());
3915                        out
3916                    }
3917                    .into()]
3918                )
3919                .build()
3920        );
3921    }
3922
3923    /// global endpoint + ip address
3924    #[test]
3925    fn test_141() {
3926        let params = crate::config::endpoint::Params::builder()
3927            .region("us-east-2".to_string())
3928            .bucket("bucket".to_string())
3929            .endpoint("http://192.168.0.1".to_string())
3930            .use_global_endpoint(true)
3931            .build()
3932            .expect("invalid params");
3933        let resolver = crate::config::endpoint::DefaultResolver::new();
3934        let endpoint = resolver.resolve_endpoint(&params);
3935        let endpoint = endpoint.expect("Expected valid endpoint: http://192.168.0.1/bucket");
3936        assert_eq!(
3937            endpoint,
3938            ::aws_smithy_types::endpoint::Endpoint::builder()
3939                .url("http://192.168.0.1/bucket")
3940                .property(
3941                    "authSchemes",
3942                    vec![{
3943                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3944                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3945                        out.insert("name".to_string(), "sigv4".to_string().into());
3946                        out.insert("signingName".to_string(), "s3".to_string().into());
3947                        out.insert("disableDoubleEncoding".to_string(), true.into());
3948                        out
3949                    }
3950                    .into()]
3951                )
3952                .build()
3953        );
3954    }
3955
3956    /// invalid outpost type
3957    #[test]
3958    fn test_142() {
3959        let params = crate::config::endpoint::Params::builder()
3960            .region("us-east-2".to_string())
3961            .bucket("bucket!".to_string())
3962            .use_global_endpoint(true)
3963            .build()
3964            .expect("invalid params");
3965        let resolver = crate::config::endpoint::DefaultResolver::new();
3966        let endpoint = resolver.resolve_endpoint(&params);
3967        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-2.amazonaws.com/bucket%21");
3968        assert_eq!(
3969            endpoint,
3970            ::aws_smithy_types::endpoint::Endpoint::builder()
3971                .url("https://s3.us-east-2.amazonaws.com/bucket%21")
3972                .property(
3973                    "authSchemes",
3974                    vec![{
3975                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3976                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3977                        out.insert("name".to_string(), "sigv4".to_string().into());
3978                        out.insert("signingName".to_string(), "s3".to_string().into());
3979                        out.insert("disableDoubleEncoding".to_string(), true.into());
3980                        out
3981                    }
3982                    .into()]
3983                )
3984                .build()
3985        );
3986    }
3987
3988    /// invalid outpost type
3989    #[test]
3990    fn test_143() {
3991        let params = crate::config::endpoint::Params::builder()
3992            .region("us-east-2".to_string())
3993            .bucket("bucket".to_string())
3994            .accelerate(true)
3995            .use_global_endpoint(true)
3996            .build()
3997            .expect("invalid params");
3998        let resolver = crate::config::endpoint::DefaultResolver::new();
3999        let endpoint = resolver.resolve_endpoint(&params);
4000        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.amazonaws.com");
4001        assert_eq!(
4002            endpoint,
4003            ::aws_smithy_types::endpoint::Endpoint::builder()
4004                .url("https://bucket.s3-accelerate.amazonaws.com")
4005                .property(
4006                    "authSchemes",
4007                    vec![{
4008                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4009                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
4010                        out.insert("name".to_string(), "sigv4".to_string().into());
4011                        out.insert("signingName".to_string(), "s3".to_string().into());
4012                        out.insert("disableDoubleEncoding".to_string(), true.into());
4013                        out
4014                    }
4015                    .into()]
4016                )
4017                .build()
4018        );
4019    }
4020
4021    /// use global endpoint + custom endpoint
4022    #[test]
4023    fn test_144() {
4024        let params = crate::config::endpoint::Params::builder()
4025            .region("us-east-2".to_string())
4026            .bucket("bucket!".to_string())
4027            .use_global_endpoint(true)
4028            .endpoint("http://foo.com".to_string())
4029            .build()
4030            .expect("invalid params");
4031        let resolver = crate::config::endpoint::DefaultResolver::new();
4032        let endpoint = resolver.resolve_endpoint(&params);
4033        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
4034        assert_eq!(
4035            endpoint,
4036            ::aws_smithy_types::endpoint::Endpoint::builder()
4037                .url("http://foo.com/bucket%21")
4038                .property(
4039                    "authSchemes",
4040                    vec![{
4041                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4042                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
4043                        out.insert("name".to_string(), "sigv4".to_string().into());
4044                        out.insert("signingName".to_string(), "s3".to_string().into());
4045                        out.insert("disableDoubleEncoding".to_string(), true.into());
4046                        out
4047                    }
4048                    .into()]
4049                )
4050                .build()
4051        );
4052    }
4053
4054    /// use global endpoint, not us-east-1, force path style
4055    #[test]
4056    fn test_145() {
4057        let params = crate::config::endpoint::Params::builder()
4058            .region("us-east-2".to_string())
4059            .bucket("bucket!".to_string())
4060            .use_global_endpoint(true)
4061            .force_path_style(true)
4062            .endpoint("http://foo.com".to_string())
4063            .build()
4064            .expect("invalid params");
4065        let resolver = crate::config::endpoint::DefaultResolver::new();
4066        let endpoint = resolver.resolve_endpoint(&params);
4067        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
4068        assert_eq!(
4069            endpoint,
4070            ::aws_smithy_types::endpoint::Endpoint::builder()
4071                .url("http://foo.com/bucket%21")
4072                .property(
4073                    "authSchemes",
4074                    vec![{
4075                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4076                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
4077                        out.insert("name".to_string(), "sigv4".to_string().into());
4078                        out.insert("signingName".to_string(), "s3".to_string().into());
4079                        out.insert("disableDoubleEncoding".to_string(), true.into());
4080                        out
4081                    }
4082                    .into()]
4083                )
4084                .build()
4085        );
4086    }
4087
4088    /// vanilla virtual addressing@us-west-2
4089    #[test]
4090    fn test_146() {
4091        let params = crate::config::endpoint::Params::builder()
4092            .accelerate(false)
4093            .bucket("bucket-name".to_string())
4094            .force_path_style(false)
4095            .region("us-west-2".to_string())
4096            .use_dual_stack(false)
4097            .use_fips(false)
4098            .build()
4099            .expect("invalid params");
4100        let resolver = crate::config::endpoint::DefaultResolver::new();
4101        let endpoint = resolver.resolve_endpoint(&params);
4102        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.us-west-2.amazonaws.com");
4103        assert_eq!(
4104            endpoint,
4105            ::aws_smithy_types::endpoint::Endpoint::builder()
4106                .url("https://bucket-name.s3.us-west-2.amazonaws.com")
4107                .property(
4108                    "authSchemes",
4109                    vec![{
4110                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4111                        out.insert("name".to_string(), "sigv4".to_string().into());
4112                        out.insert("signingName".to_string(), "s3".to_string().into());
4113                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4114                        out.insert("disableDoubleEncoding".to_string(), true.into());
4115                        out
4116                    }
4117                    .into()]
4118                )
4119                .build()
4120        );
4121    }
4122
4123    /// virtual addressing + dualstack@us-west-2
4124    #[test]
4125    fn test_147() {
4126        let params = crate::config::endpoint::Params::builder()
4127            .accelerate(false)
4128            .bucket("bucket-name".to_string())
4129            .force_path_style(false)
4130            .region("us-west-2".to_string())
4131            .use_dual_stack(true)
4132            .use_fips(false)
4133            .build()
4134            .expect("invalid params");
4135        let resolver = crate::config::endpoint::DefaultResolver::new();
4136        let endpoint = resolver.resolve_endpoint(&params);
4137        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-west-2.amazonaws.com");
4138        assert_eq!(
4139            endpoint,
4140            ::aws_smithy_types::endpoint::Endpoint::builder()
4141                .url("https://bucket-name.s3.dualstack.us-west-2.amazonaws.com")
4142                .property(
4143                    "authSchemes",
4144                    vec![{
4145                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4146                        out.insert("name".to_string(), "sigv4".to_string().into());
4147                        out.insert("signingName".to_string(), "s3".to_string().into());
4148                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4149                        out.insert("disableDoubleEncoding".to_string(), true.into());
4150                        out
4151                    }
4152                    .into()]
4153                )
4154                .build()
4155        );
4156    }
4157
4158    /// accelerate + dualstack@us-west-2
4159    #[test]
4160    fn test_148() {
4161        let params = crate::config::endpoint::Params::builder()
4162            .accelerate(true)
4163            .bucket("bucket-name".to_string())
4164            .force_path_style(false)
4165            .region("us-west-2".to_string())
4166            .use_dual_stack(true)
4167            .use_fips(false)
4168            .build()
4169            .expect("invalid params");
4170        let resolver = crate::config::endpoint::DefaultResolver::new();
4171        let endpoint = resolver.resolve_endpoint(&params);
4172        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.dualstack.amazonaws.com");
4173        assert_eq!(
4174            endpoint,
4175            ::aws_smithy_types::endpoint::Endpoint::builder()
4176                .url("https://bucket-name.s3-accelerate.dualstack.amazonaws.com")
4177                .property(
4178                    "authSchemes",
4179                    vec![{
4180                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4181                        out.insert("name".to_string(), "sigv4".to_string().into());
4182                        out.insert("signingName".to_string(), "s3".to_string().into());
4183                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4184                        out.insert("disableDoubleEncoding".to_string(), true.into());
4185                        out
4186                    }
4187                    .into()]
4188                )
4189                .build()
4190        );
4191    }
4192
4193    /// accelerate (dualstack=false)@us-west-2
4194    #[test]
4195    fn test_149() {
4196        let params = crate::config::endpoint::Params::builder()
4197            .accelerate(true)
4198            .bucket("bucket-name".to_string())
4199            .force_path_style(false)
4200            .region("us-west-2".to_string())
4201            .use_dual_stack(false)
4202            .use_fips(false)
4203            .build()
4204            .expect("invalid params");
4205        let resolver = crate::config::endpoint::DefaultResolver::new();
4206        let endpoint = resolver.resolve_endpoint(&params);
4207        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
4208        assert_eq!(
4209            endpoint,
4210            ::aws_smithy_types::endpoint::Endpoint::builder()
4211                .url("https://bucket-name.s3-accelerate.amazonaws.com")
4212                .property(
4213                    "authSchemes",
4214                    vec![{
4215                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4216                        out.insert("name".to_string(), "sigv4".to_string().into());
4217                        out.insert("signingName".to_string(), "s3".to_string().into());
4218                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4219                        out.insert("disableDoubleEncoding".to_string(), true.into());
4220                        out
4221                    }
4222                    .into()]
4223                )
4224                .build()
4225        );
4226    }
4227
4228    /// virtual addressing + fips@us-west-2
4229    #[test]
4230    fn test_150() {
4231        let params = crate::config::endpoint::Params::builder()
4232            .accelerate(false)
4233            .bucket("bucket-name".to_string())
4234            .force_path_style(false)
4235            .region("us-west-2".to_string())
4236            .use_dual_stack(false)
4237            .use_fips(true)
4238            .build()
4239            .expect("invalid params");
4240        let resolver = crate::config::endpoint::DefaultResolver::new();
4241        let endpoint = resolver.resolve_endpoint(&params);
4242        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-west-2.amazonaws.com");
4243        assert_eq!(
4244            endpoint,
4245            ::aws_smithy_types::endpoint::Endpoint::builder()
4246                .url("https://bucket-name.s3-fips.us-west-2.amazonaws.com")
4247                .property(
4248                    "authSchemes",
4249                    vec![{
4250                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4251                        out.insert("name".to_string(), "sigv4".to_string().into());
4252                        out.insert("signingName".to_string(), "s3".to_string().into());
4253                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4254                        out.insert("disableDoubleEncoding".to_string(), true.into());
4255                        out
4256                    }
4257                    .into()]
4258                )
4259                .build()
4260        );
4261    }
4262
4263    /// virtual addressing + dualstack + fips@us-west-2
4264    #[test]
4265    fn test_151() {
4266        let params = crate::config::endpoint::Params::builder()
4267            .accelerate(false)
4268            .bucket("bucket-name".to_string())
4269            .force_path_style(false)
4270            .region("us-west-2".to_string())
4271            .use_dual_stack(true)
4272            .use_fips(true)
4273            .build()
4274            .expect("invalid params");
4275        let resolver = crate::config::endpoint::DefaultResolver::new();
4276        let endpoint = resolver.resolve_endpoint(&params);
4277        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.us-west-2.amazonaws.com");
4278        assert_eq!(
4279            endpoint,
4280            ::aws_smithy_types::endpoint::Endpoint::builder()
4281                .url("https://bucket-name.s3-fips.dualstack.us-west-2.amazonaws.com")
4282                .property(
4283                    "authSchemes",
4284                    vec![{
4285                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4286                        out.insert("name".to_string(), "sigv4".to_string().into());
4287                        out.insert("signingName".to_string(), "s3".to_string().into());
4288                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4289                        out.insert("disableDoubleEncoding".to_string(), true.into());
4290                        out
4291                    }
4292                    .into()]
4293                )
4294                .build()
4295        );
4296    }
4297
4298    /// accelerate + fips = error@us-west-2
4299    #[test]
4300    fn test_152() {
4301        let params = crate::config::endpoint::Params::builder()
4302            .accelerate(true)
4303            .bucket("bucket-name".to_string())
4304            .force_path_style(false)
4305            .region("us-west-2".to_string())
4306            .use_dual_stack(false)
4307            .use_fips(true)
4308            .build()
4309            .expect("invalid params");
4310        let resolver = crate::config::endpoint::DefaultResolver::new();
4311        let endpoint = resolver.resolve_endpoint(&params);
4312        let error = endpoint.expect_err("expected error: Accelerate cannot be used with FIPS [accelerate + fips = error@us-west-2]");
4313        assert_eq!(format!("{}", error), "Accelerate cannot be used with FIPS")
4314    }
4315
4316    /// vanilla virtual addressing@cn-north-1
4317    #[test]
4318    fn test_153() {
4319        let params = crate::config::endpoint::Params::builder()
4320            .accelerate(false)
4321            .bucket("bucket-name".to_string())
4322            .force_path_style(false)
4323            .region("cn-north-1".to_string())
4324            .use_dual_stack(false)
4325            .use_fips(false)
4326            .build()
4327            .expect("invalid params");
4328        let resolver = crate::config::endpoint::DefaultResolver::new();
4329        let endpoint = resolver.resolve_endpoint(&params);
4330        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.cn-north-1.amazonaws.com.cn");
4331        assert_eq!(
4332            endpoint,
4333            ::aws_smithy_types::endpoint::Endpoint::builder()
4334                .url("https://bucket-name.s3.cn-north-1.amazonaws.com.cn")
4335                .property(
4336                    "authSchemes",
4337                    vec![{
4338                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4339                        out.insert("name".to_string(), "sigv4".to_string().into());
4340                        out.insert("signingName".to_string(), "s3".to_string().into());
4341                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4342                        out.insert("disableDoubleEncoding".to_string(), true.into());
4343                        out
4344                    }
4345                    .into()]
4346                )
4347                .build()
4348        );
4349    }
4350
4351    /// virtual addressing + dualstack@cn-north-1
4352    #[test]
4353    fn test_154() {
4354        let params = crate::config::endpoint::Params::builder()
4355            .accelerate(false)
4356            .bucket("bucket-name".to_string())
4357            .force_path_style(false)
4358            .region("cn-north-1".to_string())
4359            .use_dual_stack(true)
4360            .use_fips(false)
4361            .build()
4362            .expect("invalid params");
4363        let resolver = crate::config::endpoint::DefaultResolver::new();
4364        let endpoint = resolver.resolve_endpoint(&params);
4365        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.cn-north-1.amazonaws.com.cn");
4366        assert_eq!(
4367            endpoint,
4368            ::aws_smithy_types::endpoint::Endpoint::builder()
4369                .url("https://bucket-name.s3.dualstack.cn-north-1.amazonaws.com.cn")
4370                .property(
4371                    "authSchemes",
4372                    vec![{
4373                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4374                        out.insert("name".to_string(), "sigv4".to_string().into());
4375                        out.insert("signingName".to_string(), "s3".to_string().into());
4376                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4377                        out.insert("disableDoubleEncoding".to_string(), true.into());
4378                        out
4379                    }
4380                    .into()]
4381                )
4382                .build()
4383        );
4384    }
4385
4386    /// accelerate (dualstack=false)@cn-north-1
4387    #[test]
4388    fn test_155() {
4389        let params = crate::config::endpoint::Params::builder()
4390            .accelerate(true)
4391            .bucket("bucket-name".to_string())
4392            .force_path_style(false)
4393            .region("cn-north-1".to_string())
4394            .use_dual_stack(false)
4395            .use_fips(false)
4396            .build()
4397            .expect("invalid params");
4398        let resolver = crate::config::endpoint::DefaultResolver::new();
4399        let endpoint = resolver.resolve_endpoint(&params);
4400        let error = endpoint.expect_err("expected error: S3 Accelerate cannot be used in this region [accelerate (dualstack=false)@cn-north-1]");
4401        assert_eq!(format!("{}", error), "S3 Accelerate cannot be used in this region")
4402    }
4403
4404    /// virtual addressing + fips@cn-north-1
4405    #[test]
4406    fn test_156() {
4407        let params = crate::config::endpoint::Params::builder()
4408            .accelerate(false)
4409            .bucket("bucket-name".to_string())
4410            .force_path_style(false)
4411            .region("cn-north-1".to_string())
4412            .use_dual_stack(false)
4413            .use_fips(true)
4414            .build()
4415            .expect("invalid params");
4416        let resolver = crate::config::endpoint::DefaultResolver::new();
4417        let endpoint = resolver.resolve_endpoint(&params);
4418        let error = endpoint.expect_err("expected error: Partition does not support FIPS [virtual addressing + fips@cn-north-1]");
4419        assert_eq!(format!("{}", error), "Partition does not support FIPS")
4420    }
4421
4422    /// vanilla virtual addressing@af-south-1
4423    #[test]
4424    fn test_157() {
4425        let params = crate::config::endpoint::Params::builder()
4426            .accelerate(false)
4427            .bucket("bucket-name".to_string())
4428            .force_path_style(false)
4429            .region("af-south-1".to_string())
4430            .use_dual_stack(false)
4431            .use_fips(false)
4432            .build()
4433            .expect("invalid params");
4434        let resolver = crate::config::endpoint::DefaultResolver::new();
4435        let endpoint = resolver.resolve_endpoint(&params);
4436        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.af-south-1.amazonaws.com");
4437        assert_eq!(
4438            endpoint,
4439            ::aws_smithy_types::endpoint::Endpoint::builder()
4440                .url("https://bucket-name.s3.af-south-1.amazonaws.com")
4441                .property(
4442                    "authSchemes",
4443                    vec![{
4444                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4445                        out.insert("name".to_string(), "sigv4".to_string().into());
4446                        out.insert("signingName".to_string(), "s3".to_string().into());
4447                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4448                        out.insert("disableDoubleEncoding".to_string(), true.into());
4449                        out
4450                    }
4451                    .into()]
4452                )
4453                .build()
4454        );
4455    }
4456
4457    /// virtual addressing + dualstack@af-south-1
4458    #[test]
4459    fn test_158() {
4460        let params = crate::config::endpoint::Params::builder()
4461            .accelerate(false)
4462            .bucket("bucket-name".to_string())
4463            .force_path_style(false)
4464            .region("af-south-1".to_string())
4465            .use_dual_stack(true)
4466            .use_fips(false)
4467            .build()
4468            .expect("invalid params");
4469        let resolver = crate::config::endpoint::DefaultResolver::new();
4470        let endpoint = resolver.resolve_endpoint(&params);
4471        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.af-south-1.amazonaws.com");
4472        assert_eq!(
4473            endpoint,
4474            ::aws_smithy_types::endpoint::Endpoint::builder()
4475                .url("https://bucket-name.s3.dualstack.af-south-1.amazonaws.com")
4476                .property(
4477                    "authSchemes",
4478                    vec![{
4479                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4480                        out.insert("name".to_string(), "sigv4".to_string().into());
4481                        out.insert("signingName".to_string(), "s3".to_string().into());
4482                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4483                        out.insert("disableDoubleEncoding".to_string(), true.into());
4484                        out
4485                    }
4486                    .into()]
4487                )
4488                .build()
4489        );
4490    }
4491
4492    /// accelerate + dualstack@af-south-1
4493    #[test]
4494    fn test_159() {
4495        let params = crate::config::endpoint::Params::builder()
4496            .accelerate(true)
4497            .bucket("bucket-name".to_string())
4498            .force_path_style(false)
4499            .region("af-south-1".to_string())
4500            .use_dual_stack(true)
4501            .use_fips(false)
4502            .build()
4503            .expect("invalid params");
4504        let resolver = crate::config::endpoint::DefaultResolver::new();
4505        let endpoint = resolver.resolve_endpoint(&params);
4506        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.dualstack.amazonaws.com");
4507        assert_eq!(
4508            endpoint,
4509            ::aws_smithy_types::endpoint::Endpoint::builder()
4510                .url("https://bucket-name.s3-accelerate.dualstack.amazonaws.com")
4511                .property(
4512                    "authSchemes",
4513                    vec![{
4514                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4515                        out.insert("name".to_string(), "sigv4".to_string().into());
4516                        out.insert("signingName".to_string(), "s3".to_string().into());
4517                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4518                        out.insert("disableDoubleEncoding".to_string(), true.into());
4519                        out
4520                    }
4521                    .into()]
4522                )
4523                .build()
4524        );
4525    }
4526
4527    /// accelerate (dualstack=false)@af-south-1
4528    #[test]
4529    fn test_160() {
4530        let params = crate::config::endpoint::Params::builder()
4531            .accelerate(true)
4532            .bucket("bucket-name".to_string())
4533            .force_path_style(false)
4534            .region("af-south-1".to_string())
4535            .use_dual_stack(false)
4536            .use_fips(false)
4537            .build()
4538            .expect("invalid params");
4539        let resolver = crate::config::endpoint::DefaultResolver::new();
4540        let endpoint = resolver.resolve_endpoint(&params);
4541        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
4542        assert_eq!(
4543            endpoint,
4544            ::aws_smithy_types::endpoint::Endpoint::builder()
4545                .url("https://bucket-name.s3-accelerate.amazonaws.com")
4546                .property(
4547                    "authSchemes",
4548                    vec![{
4549                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4550                        out.insert("name".to_string(), "sigv4".to_string().into());
4551                        out.insert("signingName".to_string(), "s3".to_string().into());
4552                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4553                        out.insert("disableDoubleEncoding".to_string(), true.into());
4554                        out
4555                    }
4556                    .into()]
4557                )
4558                .build()
4559        );
4560    }
4561
4562    /// virtual addressing + fips@af-south-1
4563    #[test]
4564    fn test_161() {
4565        let params = crate::config::endpoint::Params::builder()
4566            .accelerate(false)
4567            .bucket("bucket-name".to_string())
4568            .force_path_style(false)
4569            .region("af-south-1".to_string())
4570            .use_dual_stack(false)
4571            .use_fips(true)
4572            .build()
4573            .expect("invalid params");
4574        let resolver = crate::config::endpoint::DefaultResolver::new();
4575        let endpoint = resolver.resolve_endpoint(&params);
4576        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.af-south-1.amazonaws.com");
4577        assert_eq!(
4578            endpoint,
4579            ::aws_smithy_types::endpoint::Endpoint::builder()
4580                .url("https://bucket-name.s3-fips.af-south-1.amazonaws.com")
4581                .property(
4582                    "authSchemes",
4583                    vec![{
4584                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4585                        out.insert("name".to_string(), "sigv4".to_string().into());
4586                        out.insert("signingName".to_string(), "s3".to_string().into());
4587                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4588                        out.insert("disableDoubleEncoding".to_string(), true.into());
4589                        out
4590                    }
4591                    .into()]
4592                )
4593                .build()
4594        );
4595    }
4596
4597    /// virtual addressing + dualstack + fips@af-south-1
4598    #[test]
4599    fn test_162() {
4600        let params = crate::config::endpoint::Params::builder()
4601            .accelerate(false)
4602            .bucket("bucket-name".to_string())
4603            .force_path_style(false)
4604            .region("af-south-1".to_string())
4605            .use_dual_stack(true)
4606            .use_fips(true)
4607            .build()
4608            .expect("invalid params");
4609        let resolver = crate::config::endpoint::DefaultResolver::new();
4610        let endpoint = resolver.resolve_endpoint(&params);
4611        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.af-south-1.amazonaws.com");
4612        assert_eq!(
4613            endpoint,
4614            ::aws_smithy_types::endpoint::Endpoint::builder()
4615                .url("https://bucket-name.s3-fips.dualstack.af-south-1.amazonaws.com")
4616                .property(
4617                    "authSchemes",
4618                    vec![{
4619                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4620                        out.insert("name".to_string(), "sigv4".to_string().into());
4621                        out.insert("signingName".to_string(), "s3".to_string().into());
4622                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4623                        out.insert("disableDoubleEncoding".to_string(), true.into());
4624                        out
4625                    }
4626                    .into()]
4627                )
4628                .build()
4629        );
4630    }
4631
4632    /// accelerate + fips = error@af-south-1
4633    #[test]
4634    fn test_163() {
4635        let params = crate::config::endpoint::Params::builder()
4636            .accelerate(true)
4637            .bucket("bucket-name".to_string())
4638            .force_path_style(false)
4639            .region("af-south-1".to_string())
4640            .use_dual_stack(false)
4641            .use_fips(true)
4642            .build()
4643            .expect("invalid params");
4644        let resolver = crate::config::endpoint::DefaultResolver::new();
4645        let endpoint = resolver.resolve_endpoint(&params);
4646        let error = endpoint.expect_err("expected error: Accelerate cannot be used with FIPS [accelerate + fips = error@af-south-1]");
4647        assert_eq!(format!("{}", error), "Accelerate cannot be used with FIPS")
4648    }
4649
4650    /// vanilla path style@us-west-2
4651    #[test]
4652    fn test_164() {
4653        let params = crate::config::endpoint::Params::builder()
4654            .accelerate(false)
4655            .bucket("bucket-name".to_string())
4656            .force_path_style(true)
4657            .region("us-west-2".to_string())
4658            .use_dual_stack(false)
4659            .use_fips(false)
4660            .build()
4661            .expect("invalid params");
4662        let resolver = crate::config::endpoint::DefaultResolver::new();
4663        let endpoint = resolver.resolve_endpoint(&params);
4664        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket-name");
4665        assert_eq!(
4666            endpoint,
4667            ::aws_smithy_types::endpoint::Endpoint::builder()
4668                .url("https://s3.us-west-2.amazonaws.com/bucket-name")
4669                .property(
4670                    "authSchemes",
4671                    vec![{
4672                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4673                        out.insert("name".to_string(), "sigv4".to_string().into());
4674                        out.insert("signingName".to_string(), "s3".to_string().into());
4675                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4676                        out.insert("disableDoubleEncoding".to_string(), true.into());
4677                        out
4678                    }
4679                    .into()]
4680                )
4681                .build()
4682        );
4683    }
4684
4685    /// fips@us-gov-west-2, bucket is not S3-dns-compatible (subdomains)
4686    #[test]
4687    fn test_165() {
4688        let params = crate::config::endpoint::Params::builder()
4689            .accelerate(false)
4690            .bucket("bucket.with.dots".to_string())
4691            .region("us-gov-west-1".to_string())
4692            .use_dual_stack(false)
4693            .use_fips(true)
4694            .build()
4695            .expect("invalid params");
4696        let resolver = crate::config::endpoint::DefaultResolver::new();
4697        let endpoint = resolver.resolve_endpoint(&params);
4698        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-gov-west-1.amazonaws.com/bucket.with.dots");
4699        assert_eq!(
4700            endpoint,
4701            ::aws_smithy_types::endpoint::Endpoint::builder()
4702                .url("https://s3-fips.us-gov-west-1.amazonaws.com/bucket.with.dots")
4703                .property(
4704                    "authSchemes",
4705                    vec![{
4706                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4707                        out.insert("signingName".to_string(), "s3".to_string().into());
4708                        out.insert("signingRegion".to_string(), "us-gov-west-1".to_string().into());
4709                        out.insert("disableDoubleEncoding".to_string(), true.into());
4710                        out.insert("name".to_string(), "sigv4".to_string().into());
4711                        out
4712                    }
4713                    .into()]
4714                )
4715                .build()
4716        );
4717    }
4718
4719    /// path style + accelerate = error@us-west-2
4720    #[test]
4721    fn test_166() {
4722        let params = crate::config::endpoint::Params::builder()
4723            .accelerate(true)
4724            .bucket("bucket-name".to_string())
4725            .force_path_style(true)
4726            .region("us-west-2".to_string())
4727            .use_dual_stack(false)
4728            .use_fips(false)
4729            .build()
4730            .expect("invalid params");
4731        let resolver = crate::config::endpoint::DefaultResolver::new();
4732        let endpoint = resolver.resolve_endpoint(&params);
4733        let error = endpoint
4734            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@us-west-2]");
4735        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
4736    }
4737
4738    /// path style + dualstack@us-west-2
4739    #[test]
4740    fn test_167() {
4741        let params = crate::config::endpoint::Params::builder()
4742            .accelerate(false)
4743            .bucket("bucket-name".to_string())
4744            .force_path_style(true)
4745            .region("us-west-2".to_string())
4746            .use_dual_stack(true)
4747            .use_fips(false)
4748            .build()
4749            .expect("invalid params");
4750        let resolver = crate::config::endpoint::DefaultResolver::new();
4751        let endpoint = resolver.resolve_endpoint(&params);
4752        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/bucket-name");
4753        assert_eq!(
4754            endpoint,
4755            ::aws_smithy_types::endpoint::Endpoint::builder()
4756                .url("https://s3.dualstack.us-west-2.amazonaws.com/bucket-name")
4757                .property(
4758                    "authSchemes",
4759                    vec![{
4760                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4761                        out.insert("name".to_string(), "sigv4".to_string().into());
4762                        out.insert("signingName".to_string(), "s3".to_string().into());
4763                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4764                        out.insert("disableDoubleEncoding".to_string(), true.into());
4765                        out
4766                    }
4767                    .into()]
4768                )
4769                .build()
4770        );
4771    }
4772
4773    /// path style + arn is error@us-west-2
4774    #[test]
4775    fn test_168() {
4776        let params = crate::config::endpoint::Params::builder()
4777            .accelerate(false)
4778            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
4779            .force_path_style(true)
4780            .region("us-west-2".to_string())
4781            .use_dual_stack(false)
4782            .use_fips(false)
4783            .build()
4784            .expect("invalid params");
4785        let resolver = crate::config::endpoint::DefaultResolver::new();
4786        let endpoint = resolver.resolve_endpoint(&params);
4787        let error =
4788            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@us-west-2]");
4789        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
4790    }
4791
4792    /// path style + invalid DNS name@us-west-2
4793    #[test]
4794    fn test_169() {
4795        let params = crate::config::endpoint::Params::builder()
4796            .accelerate(false)
4797            .bucket("99a_b".to_string())
4798            .force_path_style(true)
4799            .region("us-west-2".to_string())
4800            .use_dual_stack(false)
4801            .use_fips(false)
4802            .build()
4803            .expect("invalid params");
4804        let resolver = crate::config::endpoint::DefaultResolver::new();
4805        let endpoint = resolver.resolve_endpoint(&params);
4806        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/99a_b");
4807        assert_eq!(
4808            endpoint,
4809            ::aws_smithy_types::endpoint::Endpoint::builder()
4810                .url("https://s3.us-west-2.amazonaws.com/99a_b")
4811                .property(
4812                    "authSchemes",
4813                    vec![{
4814                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4815                        out.insert("name".to_string(), "sigv4".to_string().into());
4816                        out.insert("signingName".to_string(), "s3".to_string().into());
4817                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4818                        out.insert("disableDoubleEncoding".to_string(), true.into());
4819                        out
4820                    }
4821                    .into()]
4822                )
4823                .build()
4824        );
4825    }
4826
4827    /// no path style + invalid DNS name@us-west-2
4828    #[test]
4829    fn test_170() {
4830        let params = crate::config::endpoint::Params::builder()
4831            .accelerate(false)
4832            .bucket("99a_b".to_string())
4833            .region("us-west-2".to_string())
4834            .use_dual_stack(false)
4835            .use_fips(false)
4836            .build()
4837            .expect("invalid params");
4838        let resolver = crate::config::endpoint::DefaultResolver::new();
4839        let endpoint = resolver.resolve_endpoint(&params);
4840        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/99a_b");
4841        assert_eq!(
4842            endpoint,
4843            ::aws_smithy_types::endpoint::Endpoint::builder()
4844                .url("https://s3.us-west-2.amazonaws.com/99a_b")
4845                .property(
4846                    "authSchemes",
4847                    vec![{
4848                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4849                        out.insert("name".to_string(), "sigv4".to_string().into());
4850                        out.insert("signingName".to_string(), "s3".to_string().into());
4851                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4852                        out.insert("disableDoubleEncoding".to_string(), true.into());
4853                        out
4854                    }
4855                    .into()]
4856                )
4857                .build()
4858        );
4859    }
4860
4861    /// vanilla path style@cn-north-1
4862    #[test]
4863    fn test_171() {
4864        let params = crate::config::endpoint::Params::builder()
4865            .accelerate(false)
4866            .bucket("bucket-name".to_string())
4867            .force_path_style(true)
4868            .region("cn-north-1".to_string())
4869            .use_dual_stack(false)
4870            .use_fips(false)
4871            .build()
4872            .expect("invalid params");
4873        let resolver = crate::config::endpoint::DefaultResolver::new();
4874        let endpoint = resolver.resolve_endpoint(&params);
4875        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/bucket-name");
4876        assert_eq!(
4877            endpoint,
4878            ::aws_smithy_types::endpoint::Endpoint::builder()
4879                .url("https://s3.cn-north-1.amazonaws.com.cn/bucket-name")
4880                .property(
4881                    "authSchemes",
4882                    vec![{
4883                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4884                        out.insert("name".to_string(), "sigv4".to_string().into());
4885                        out.insert("signingName".to_string(), "s3".to_string().into());
4886                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4887                        out.insert("disableDoubleEncoding".to_string(), true.into());
4888                        out
4889                    }
4890                    .into()]
4891                )
4892                .build()
4893        );
4894    }
4895
4896    /// path style + fips@cn-north-1
4897    #[test]
4898    fn test_172() {
4899        let params = crate::config::endpoint::Params::builder()
4900            .accelerate(false)
4901            .bucket("bucket-name".to_string())
4902            .force_path_style(true)
4903            .region("cn-north-1".to_string())
4904            .use_dual_stack(false)
4905            .use_fips(true)
4906            .build()
4907            .expect("invalid params");
4908        let resolver = crate::config::endpoint::DefaultResolver::new();
4909        let endpoint = resolver.resolve_endpoint(&params);
4910        let error = endpoint.expect_err("expected error: Partition does not support FIPS [path style + fips@cn-north-1]");
4911        assert_eq!(format!("{}", error), "Partition does not support FIPS")
4912    }
4913
4914    /// path style + accelerate = error@cn-north-1
4915    #[test]
4916    fn test_173() {
4917        let params = crate::config::endpoint::Params::builder()
4918            .accelerate(true)
4919            .bucket("bucket-name".to_string())
4920            .force_path_style(true)
4921            .region("cn-north-1".to_string())
4922            .use_dual_stack(false)
4923            .use_fips(false)
4924            .build()
4925            .expect("invalid params");
4926        let resolver = crate::config::endpoint::DefaultResolver::new();
4927        let endpoint = resolver.resolve_endpoint(&params);
4928        let error = endpoint
4929            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@cn-north-1]");
4930        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
4931    }
4932
4933    /// path style + dualstack@cn-north-1
4934    #[test]
4935    fn test_174() {
4936        let params = crate::config::endpoint::Params::builder()
4937            .accelerate(false)
4938            .bucket("bucket-name".to_string())
4939            .force_path_style(true)
4940            .region("cn-north-1".to_string())
4941            .use_dual_stack(true)
4942            .use_fips(false)
4943            .build()
4944            .expect("invalid params");
4945        let resolver = crate::config::endpoint::DefaultResolver::new();
4946        let endpoint = resolver.resolve_endpoint(&params);
4947        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.cn-north-1.amazonaws.com.cn/bucket-name");
4948        assert_eq!(
4949            endpoint,
4950            ::aws_smithy_types::endpoint::Endpoint::builder()
4951                .url("https://s3.dualstack.cn-north-1.amazonaws.com.cn/bucket-name")
4952                .property(
4953                    "authSchemes",
4954                    vec![{
4955                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4956                        out.insert("name".to_string(), "sigv4".to_string().into());
4957                        out.insert("signingName".to_string(), "s3".to_string().into());
4958                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4959                        out.insert("disableDoubleEncoding".to_string(), true.into());
4960                        out
4961                    }
4962                    .into()]
4963                )
4964                .build()
4965        );
4966    }
4967
4968    /// path style + arn is error@cn-north-1
4969    #[test]
4970    fn test_175() {
4971        let params = crate::config::endpoint::Params::builder()
4972            .accelerate(false)
4973            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
4974            .force_path_style(true)
4975            .region("cn-north-1".to_string())
4976            .use_dual_stack(false)
4977            .use_fips(false)
4978            .build()
4979            .expect("invalid params");
4980        let resolver = crate::config::endpoint::DefaultResolver::new();
4981        let endpoint = resolver.resolve_endpoint(&params);
4982        let error =
4983            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@cn-north-1]");
4984        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
4985    }
4986
4987    /// path style + invalid DNS name@cn-north-1
4988    #[test]
4989    fn test_176() {
4990        let params = crate::config::endpoint::Params::builder()
4991            .accelerate(false)
4992            .bucket("99a_b".to_string())
4993            .force_path_style(true)
4994            .region("cn-north-1".to_string())
4995            .use_dual_stack(false)
4996            .use_fips(false)
4997            .build()
4998            .expect("invalid params");
4999        let resolver = crate::config::endpoint::DefaultResolver::new();
5000        let endpoint = resolver.resolve_endpoint(&params);
5001        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/99a_b");
5002        assert_eq!(
5003            endpoint,
5004            ::aws_smithy_types::endpoint::Endpoint::builder()
5005                .url("https://s3.cn-north-1.amazonaws.com.cn/99a_b")
5006                .property(
5007                    "authSchemes",
5008                    vec![{
5009                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5010                        out.insert("name".to_string(), "sigv4".to_string().into());
5011                        out.insert("signingName".to_string(), "s3".to_string().into());
5012                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5013                        out.insert("disableDoubleEncoding".to_string(), true.into());
5014                        out
5015                    }
5016                    .into()]
5017                )
5018                .build()
5019        );
5020    }
5021
5022    /// no path style + invalid DNS name@cn-north-1
5023    #[test]
5024    fn test_177() {
5025        let params = crate::config::endpoint::Params::builder()
5026            .accelerate(false)
5027            .bucket("99a_b".to_string())
5028            .region("cn-north-1".to_string())
5029            .use_dual_stack(false)
5030            .use_fips(false)
5031            .build()
5032            .expect("invalid params");
5033        let resolver = crate::config::endpoint::DefaultResolver::new();
5034        let endpoint = resolver.resolve_endpoint(&params);
5035        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/99a_b");
5036        assert_eq!(
5037            endpoint,
5038            ::aws_smithy_types::endpoint::Endpoint::builder()
5039                .url("https://s3.cn-north-1.amazonaws.com.cn/99a_b")
5040                .property(
5041                    "authSchemes",
5042                    vec![{
5043                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5044                        out.insert("name".to_string(), "sigv4".to_string().into());
5045                        out.insert("signingName".to_string(), "s3".to_string().into());
5046                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5047                        out.insert("disableDoubleEncoding".to_string(), true.into());
5048                        out
5049                    }
5050                    .into()]
5051                )
5052                .build()
5053        );
5054    }
5055
5056    /// vanilla path style@af-south-1
5057    #[test]
5058    fn test_178() {
5059        let params = crate::config::endpoint::Params::builder()
5060            .accelerate(false)
5061            .bucket("bucket-name".to_string())
5062            .force_path_style(true)
5063            .region("af-south-1".to_string())
5064            .use_dual_stack(false)
5065            .use_fips(false)
5066            .build()
5067            .expect("invalid params");
5068        let resolver = crate::config::endpoint::DefaultResolver::new();
5069        let endpoint = resolver.resolve_endpoint(&params);
5070        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/bucket-name");
5071        assert_eq!(
5072            endpoint,
5073            ::aws_smithy_types::endpoint::Endpoint::builder()
5074                .url("https://s3.af-south-1.amazonaws.com/bucket-name")
5075                .property(
5076                    "authSchemes",
5077                    vec![{
5078                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5079                        out.insert("name".to_string(), "sigv4".to_string().into());
5080                        out.insert("signingName".to_string(), "s3".to_string().into());
5081                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5082                        out.insert("disableDoubleEncoding".to_string(), true.into());
5083                        out
5084                    }
5085                    .into()]
5086                )
5087                .build()
5088        );
5089    }
5090
5091    /// path style + fips@af-south-1
5092    #[test]
5093    fn test_179() {
5094        let params = crate::config::endpoint::Params::builder()
5095            .accelerate(false)
5096            .bucket("bucket-name".to_string())
5097            .force_path_style(true)
5098            .region("af-south-1".to_string())
5099            .use_dual_stack(false)
5100            .use_fips(true)
5101            .build()
5102            .expect("invalid params");
5103        let resolver = crate::config::endpoint::DefaultResolver::new();
5104        let endpoint = resolver.resolve_endpoint(&params);
5105        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.af-south-1.amazonaws.com/bucket-name");
5106        assert_eq!(
5107            endpoint,
5108            ::aws_smithy_types::endpoint::Endpoint::builder()
5109                .url("https://s3-fips.af-south-1.amazonaws.com/bucket-name")
5110                .property(
5111                    "authSchemes",
5112                    vec![{
5113                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5114                        out.insert("signingName".to_string(), "s3".to_string().into());
5115                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5116                        out.insert("disableDoubleEncoding".to_string(), true.into());
5117                        out.insert("name".to_string(), "sigv4".to_string().into());
5118                        out
5119                    }
5120                    .into()]
5121                )
5122                .build()
5123        );
5124    }
5125
5126    /// path style + accelerate = error@af-south-1
5127    #[test]
5128    fn test_180() {
5129        let params = crate::config::endpoint::Params::builder()
5130            .accelerate(true)
5131            .bucket("bucket-name".to_string())
5132            .force_path_style(true)
5133            .region("af-south-1".to_string())
5134            .use_dual_stack(false)
5135            .use_fips(false)
5136            .build()
5137            .expect("invalid params");
5138        let resolver = crate::config::endpoint::DefaultResolver::new();
5139        let endpoint = resolver.resolve_endpoint(&params);
5140        let error = endpoint
5141            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@af-south-1]");
5142        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
5143    }
5144
5145    /// path style + dualstack@af-south-1
5146    #[test]
5147    fn test_181() {
5148        let params = crate::config::endpoint::Params::builder()
5149            .accelerate(false)
5150            .bucket("bucket-name".to_string())
5151            .force_path_style(true)
5152            .region("af-south-1".to_string())
5153            .use_dual_stack(true)
5154            .use_fips(false)
5155            .build()
5156            .expect("invalid params");
5157        let resolver = crate::config::endpoint::DefaultResolver::new();
5158        let endpoint = resolver.resolve_endpoint(&params);
5159        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.af-south-1.amazonaws.com/bucket-name");
5160        assert_eq!(
5161            endpoint,
5162            ::aws_smithy_types::endpoint::Endpoint::builder()
5163                .url("https://s3.dualstack.af-south-1.amazonaws.com/bucket-name")
5164                .property(
5165                    "authSchemes",
5166                    vec![{
5167                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5168                        out.insert("name".to_string(), "sigv4".to_string().into());
5169                        out.insert("signingName".to_string(), "s3".to_string().into());
5170                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5171                        out.insert("disableDoubleEncoding".to_string(), true.into());
5172                        out
5173                    }
5174                    .into()]
5175                )
5176                .build()
5177        );
5178    }
5179
5180    /// path style + arn is error@af-south-1
5181    #[test]
5182    fn test_182() {
5183        let params = crate::config::endpoint::Params::builder()
5184            .accelerate(false)
5185            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
5186            .force_path_style(true)
5187            .region("af-south-1".to_string())
5188            .use_dual_stack(false)
5189            .use_fips(false)
5190            .build()
5191            .expect("invalid params");
5192        let resolver = crate::config::endpoint::DefaultResolver::new();
5193        let endpoint = resolver.resolve_endpoint(&params);
5194        let error =
5195            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@af-south-1]");
5196        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
5197    }
5198
5199    /// path style + invalid DNS name@af-south-1
5200    #[test]
5201    fn test_183() {
5202        let params = crate::config::endpoint::Params::builder()
5203            .accelerate(false)
5204            .bucket("99a_b".to_string())
5205            .force_path_style(true)
5206            .region("af-south-1".to_string())
5207            .use_dual_stack(false)
5208            .use_fips(false)
5209            .build()
5210            .expect("invalid params");
5211        let resolver = crate::config::endpoint::DefaultResolver::new();
5212        let endpoint = resolver.resolve_endpoint(&params);
5213        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/99a_b");
5214        assert_eq!(
5215            endpoint,
5216            ::aws_smithy_types::endpoint::Endpoint::builder()
5217                .url("https://s3.af-south-1.amazonaws.com/99a_b")
5218                .property(
5219                    "authSchemes",
5220                    vec![{
5221                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5222                        out.insert("name".to_string(), "sigv4".to_string().into());
5223                        out.insert("signingName".to_string(), "s3".to_string().into());
5224                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5225                        out.insert("disableDoubleEncoding".to_string(), true.into());
5226                        out
5227                    }
5228                    .into()]
5229                )
5230                .build()
5231        );
5232    }
5233
5234    /// no path style + invalid DNS name@af-south-1
5235    #[test]
5236    fn test_184() {
5237        let params = crate::config::endpoint::Params::builder()
5238            .accelerate(false)
5239            .bucket("99a_b".to_string())
5240            .region("af-south-1".to_string())
5241            .use_dual_stack(false)
5242            .use_fips(false)
5243            .build()
5244            .expect("invalid params");
5245        let resolver = crate::config::endpoint::DefaultResolver::new();
5246        let endpoint = resolver.resolve_endpoint(&params);
5247        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/99a_b");
5248        assert_eq!(
5249            endpoint,
5250            ::aws_smithy_types::endpoint::Endpoint::builder()
5251                .url("https://s3.af-south-1.amazonaws.com/99a_b")
5252                .property(
5253                    "authSchemes",
5254                    vec![{
5255                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5256                        out.insert("name".to_string(), "sigv4".to_string().into());
5257                        out.insert("signingName".to_string(), "s3".to_string().into());
5258                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5259                        out.insert("disableDoubleEncoding".to_string(), true.into());
5260                        out
5261                    }
5262                    .into()]
5263                )
5264                .build()
5265        );
5266    }
5267
5268    /// virtual addressing + private link@us-west-2
5269    #[test]
5270    fn test_185() {
5271        let params = crate::config::endpoint::Params::builder()
5272            .accelerate(false)
5273            .bucket("bucket-name".to_string())
5274            .force_path_style(false)
5275            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5276            .region("us-west-2".to_string())
5277            .use_dual_stack(false)
5278            .use_fips(false)
5279            .build()
5280            .expect("invalid params");
5281        let resolver = crate::config::endpoint::DefaultResolver::new();
5282        let endpoint = resolver.resolve_endpoint(&params);
5283        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
5284        assert_eq!(
5285            endpoint,
5286            ::aws_smithy_types::endpoint::Endpoint::builder()
5287                .url("http://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
5288                .property(
5289                    "authSchemes",
5290                    vec![{
5291                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5292                        out.insert("name".to_string(), "sigv4".to_string().into());
5293                        out.insert("signingName".to_string(), "s3".to_string().into());
5294                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5295                        out.insert("disableDoubleEncoding".to_string(), true.into());
5296                        out
5297                    }
5298                    .into()]
5299                )
5300                .build()
5301        );
5302    }
5303
5304    /// path style + private link@us-west-2
5305    #[test]
5306    fn test_186() {
5307        let params = crate::config::endpoint::Params::builder()
5308            .accelerate(false)
5309            .bucket("bucket-name".to_string())
5310            .force_path_style(true)
5311            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5312            .region("us-west-2".to_string())
5313            .use_dual_stack(false)
5314            .use_fips(false)
5315            .build()
5316            .expect("invalid params");
5317        let resolver = crate::config::endpoint::DefaultResolver::new();
5318        let endpoint = resolver.resolve_endpoint(&params);
5319        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
5320        assert_eq!(
5321            endpoint,
5322            ::aws_smithy_types::endpoint::Endpoint::builder()
5323                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
5324                .property(
5325                    "authSchemes",
5326                    vec![{
5327                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5328                        out.insert("name".to_string(), "sigv4".to_string().into());
5329                        out.insert("signingName".to_string(), "s3".to_string().into());
5330                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5331                        out.insert("disableDoubleEncoding".to_string(), true.into());
5332                        out
5333                    }
5334                    .into()]
5335                )
5336                .build()
5337        );
5338    }
5339
5340    /// SDK::Host + FIPS@us-west-2
5341    #[test]
5342    fn test_187() {
5343        let params = crate::config::endpoint::Params::builder()
5344            .accelerate(false)
5345            .bucket("bucket-name".to_string())
5346            .force_path_style(false)
5347            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5348            .region("us-west-2".to_string())
5349            .use_dual_stack(false)
5350            .use_fips(true)
5351            .build()
5352            .expect("invalid params");
5353        let resolver = crate::config::endpoint::DefaultResolver::new();
5354        let endpoint = resolver.resolve_endpoint(&params);
5355        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [SDK::Host + FIPS@us-west-2]");
5356        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
5357    }
5358
5359    /// SDK::Host + DualStack@us-west-2
5360    #[test]
5361    fn test_188() {
5362        let params = crate::config::endpoint::Params::builder()
5363            .accelerate(false)
5364            .bucket("bucket-name".to_string())
5365            .force_path_style(false)
5366            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5367            .region("us-west-2".to_string())
5368            .use_dual_stack(true)
5369            .use_fips(false)
5370            .build()
5371            .expect("invalid params");
5372        let resolver = crate::config::endpoint::DefaultResolver::new();
5373        let endpoint = resolver.resolve_endpoint(&params);
5374        let error =
5375            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@us-west-2]");
5376        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
5377    }
5378
5379    /// SDK::HOST + accelerate@us-west-2
5380    #[test]
5381    fn test_189() {
5382        let params = crate::config::endpoint::Params::builder()
5383            .accelerate(true)
5384            .bucket("bucket-name".to_string())
5385            .force_path_style(false)
5386            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5387            .region("us-west-2".to_string())
5388            .use_dual_stack(false)
5389            .use_fips(false)
5390            .build()
5391            .expect("invalid params");
5392        let resolver = crate::config::endpoint::DefaultResolver::new();
5393        let endpoint = resolver.resolve_endpoint(&params);
5394        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@us-west-2]");
5395        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
5396    }
5397
5398    /// SDK::Host + access point ARN@us-west-2
5399    #[test]
5400    fn test_190() {
5401        let params = crate::config::endpoint::Params::builder()
5402            .accelerate(false)
5403            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5404            .force_path_style(false)
5405            .endpoint("https://beta.example.com".to_string())
5406            .region("us-west-2".to_string())
5407            .use_dual_stack(false)
5408            .use_fips(false)
5409            .build()
5410            .expect("invalid params");
5411        let resolver = crate::config::endpoint::DefaultResolver::new();
5412        let endpoint = resolver.resolve_endpoint(&params);
5413        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
5414        assert_eq!(
5415            endpoint,
5416            ::aws_smithy_types::endpoint::Endpoint::builder()
5417                .url("https://myendpoint-123456789012.beta.example.com")
5418                .property(
5419                    "authSchemes",
5420                    vec![{
5421                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5422                        out.insert("name".to_string(), "sigv4".to_string().into());
5423                        out.insert("signingName".to_string(), "s3".to_string().into());
5424                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5425                        out.insert("disableDoubleEncoding".to_string(), true.into());
5426                        out
5427                    }
5428                    .into()]
5429                )
5430                .build()
5431        );
5432    }
5433
5434    /// virtual addressing + private link@cn-north-1
5435    #[test]
5436    fn test_191() {
5437        let params = crate::config::endpoint::Params::builder()
5438            .accelerate(false)
5439            .bucket("bucket-name".to_string())
5440            .force_path_style(false)
5441            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5442            .region("cn-north-1".to_string())
5443            .use_dual_stack(false)
5444            .use_fips(false)
5445            .build()
5446            .expect("invalid params");
5447        let resolver = crate::config::endpoint::DefaultResolver::new();
5448        let endpoint = resolver.resolve_endpoint(&params);
5449        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
5450        assert_eq!(
5451            endpoint,
5452            ::aws_smithy_types::endpoint::Endpoint::builder()
5453                .url("https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
5454                .property(
5455                    "authSchemes",
5456                    vec![{
5457                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5458                        out.insert("name".to_string(), "sigv4".to_string().into());
5459                        out.insert("signingName".to_string(), "s3".to_string().into());
5460                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5461                        out.insert("disableDoubleEncoding".to_string(), true.into());
5462                        out
5463                    }
5464                    .into()]
5465                )
5466                .build()
5467        );
5468    }
5469
5470    /// path style + private link@cn-north-1
5471    #[test]
5472    fn test_192() {
5473        let params = crate::config::endpoint::Params::builder()
5474            .accelerate(false)
5475            .bucket("bucket-name".to_string())
5476            .force_path_style(true)
5477            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5478            .region("cn-north-1".to_string())
5479            .use_dual_stack(false)
5480            .use_fips(false)
5481            .build()
5482            .expect("invalid params");
5483        let resolver = crate::config::endpoint::DefaultResolver::new();
5484        let endpoint = resolver.resolve_endpoint(&params);
5485        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
5486        assert_eq!(
5487            endpoint,
5488            ::aws_smithy_types::endpoint::Endpoint::builder()
5489                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
5490                .property(
5491                    "authSchemes",
5492                    vec![{
5493                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5494                        out.insert("name".to_string(), "sigv4".to_string().into());
5495                        out.insert("signingName".to_string(), "s3".to_string().into());
5496                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5497                        out.insert("disableDoubleEncoding".to_string(), true.into());
5498                        out
5499                    }
5500                    .into()]
5501                )
5502                .build()
5503        );
5504    }
5505
5506    /// FIPS@cn-north-1
5507    #[test]
5508    fn test_193() {
5509        let params = crate::config::endpoint::Params::builder()
5510            .accelerate(false)
5511            .bucket("bucket-name".to_string())
5512            .force_path_style(false)
5513            .region("cn-north-1".to_string())
5514            .use_dual_stack(false)
5515            .use_fips(true)
5516            .build()
5517            .expect("invalid params");
5518        let resolver = crate::config::endpoint::DefaultResolver::new();
5519        let endpoint = resolver.resolve_endpoint(&params);
5520        let error = endpoint.expect_err("expected error: Partition does not support FIPS [FIPS@cn-north-1]");
5521        assert_eq!(format!("{}", error), "Partition does not support FIPS")
5522    }
5523
5524    /// SDK::Host + DualStack@cn-north-1
5525    #[test]
5526    fn test_194() {
5527        let params = crate::config::endpoint::Params::builder()
5528            .accelerate(false)
5529            .bucket("bucket-name".to_string())
5530            .force_path_style(false)
5531            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5532            .region("cn-north-1".to_string())
5533            .use_dual_stack(true)
5534            .use_fips(false)
5535            .build()
5536            .expect("invalid params");
5537        let resolver = crate::config::endpoint::DefaultResolver::new();
5538        let endpoint = resolver.resolve_endpoint(&params);
5539        let error =
5540            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@cn-north-1]");
5541        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
5542    }
5543
5544    /// SDK::HOST + accelerate@cn-north-1
5545    #[test]
5546    fn test_195() {
5547        let params = crate::config::endpoint::Params::builder()
5548            .accelerate(true)
5549            .bucket("bucket-name".to_string())
5550            .force_path_style(false)
5551            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5552            .region("cn-north-1".to_string())
5553            .use_dual_stack(false)
5554            .use_fips(false)
5555            .build()
5556            .expect("invalid params");
5557        let resolver = crate::config::endpoint::DefaultResolver::new();
5558        let endpoint = resolver.resolve_endpoint(&params);
5559        let error =
5560            endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@cn-north-1]");
5561        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
5562    }
5563
5564    /// SDK::Host + access point ARN@cn-north-1
5565    #[test]
5566    fn test_196() {
5567        let params = crate::config::endpoint::Params::builder()
5568            .accelerate(false)
5569            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5570            .force_path_style(false)
5571            .endpoint("https://beta.example.com".to_string())
5572            .region("cn-north-1".to_string())
5573            .use_dual_stack(false)
5574            .use_fips(false)
5575            .build()
5576            .expect("invalid params");
5577        let resolver = crate::config::endpoint::DefaultResolver::new();
5578        let endpoint = resolver.resolve_endpoint(&params);
5579        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
5580        assert_eq!(
5581            endpoint,
5582            ::aws_smithy_types::endpoint::Endpoint::builder()
5583                .url("https://myendpoint-123456789012.beta.example.com")
5584                .property(
5585                    "authSchemes",
5586                    vec![{
5587                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5588                        out.insert("name".to_string(), "sigv4".to_string().into());
5589                        out.insert("signingName".to_string(), "s3".to_string().into());
5590                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5591                        out.insert("disableDoubleEncoding".to_string(), true.into());
5592                        out
5593                    }
5594                    .into()]
5595                )
5596                .build()
5597        );
5598    }
5599
5600    /// virtual addressing + private link@af-south-1
5601    #[test]
5602    fn test_197() {
5603        let params = crate::config::endpoint::Params::builder()
5604            .accelerate(false)
5605            .bucket("bucket-name".to_string())
5606            .force_path_style(false)
5607            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5608            .region("af-south-1".to_string())
5609            .use_dual_stack(false)
5610            .use_fips(false)
5611            .build()
5612            .expect("invalid params");
5613        let resolver = crate::config::endpoint::DefaultResolver::new();
5614        let endpoint = resolver.resolve_endpoint(&params);
5615        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
5616        assert_eq!(
5617            endpoint,
5618            ::aws_smithy_types::endpoint::Endpoint::builder()
5619                .url("https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
5620                .property(
5621                    "authSchemes",
5622                    vec![{
5623                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5624                        out.insert("name".to_string(), "sigv4".to_string().into());
5625                        out.insert("signingName".to_string(), "s3".to_string().into());
5626                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5627                        out.insert("disableDoubleEncoding".to_string(), true.into());
5628                        out
5629                    }
5630                    .into()]
5631                )
5632                .build()
5633        );
5634    }
5635
5636    /// path style + private link@af-south-1
5637    #[test]
5638    fn test_198() {
5639        let params = crate::config::endpoint::Params::builder()
5640            .accelerate(false)
5641            .bucket("bucket-name".to_string())
5642            .force_path_style(true)
5643            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5644            .region("af-south-1".to_string())
5645            .use_dual_stack(false)
5646            .use_fips(false)
5647            .build()
5648            .expect("invalid params");
5649        let resolver = crate::config::endpoint::DefaultResolver::new();
5650        let endpoint = resolver.resolve_endpoint(&params);
5651        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
5652        assert_eq!(
5653            endpoint,
5654            ::aws_smithy_types::endpoint::Endpoint::builder()
5655                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
5656                .property(
5657                    "authSchemes",
5658                    vec![{
5659                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5660                        out.insert("name".to_string(), "sigv4".to_string().into());
5661                        out.insert("signingName".to_string(), "s3".to_string().into());
5662                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5663                        out.insert("disableDoubleEncoding".to_string(), true.into());
5664                        out
5665                    }
5666                    .into()]
5667                )
5668                .build()
5669        );
5670    }
5671
5672    /// SDK::Host + FIPS@af-south-1
5673    #[test]
5674    fn test_199() {
5675        let params = crate::config::endpoint::Params::builder()
5676            .accelerate(false)
5677            .bucket("bucket-name".to_string())
5678            .force_path_style(false)
5679            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5680            .region("af-south-1".to_string())
5681            .use_dual_stack(false)
5682            .use_fips(true)
5683            .build()
5684            .expect("invalid params");
5685        let resolver = crate::config::endpoint::DefaultResolver::new();
5686        let endpoint = resolver.resolve_endpoint(&params);
5687        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [SDK::Host + FIPS@af-south-1]");
5688        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
5689    }
5690
5691    /// SDK::Host + DualStack@af-south-1
5692    #[test]
5693    fn test_200() {
5694        let params = crate::config::endpoint::Params::builder()
5695            .accelerate(false)
5696            .bucket("bucket-name".to_string())
5697            .force_path_style(false)
5698            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5699            .region("af-south-1".to_string())
5700            .use_dual_stack(true)
5701            .use_fips(false)
5702            .build()
5703            .expect("invalid params");
5704        let resolver = crate::config::endpoint::DefaultResolver::new();
5705        let endpoint = resolver.resolve_endpoint(&params);
5706        let error =
5707            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@af-south-1]");
5708        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
5709    }
5710
5711    /// SDK::HOST + accelerate@af-south-1
5712    #[test]
5713    fn test_201() {
5714        let params = crate::config::endpoint::Params::builder()
5715            .accelerate(true)
5716            .bucket("bucket-name".to_string())
5717            .force_path_style(false)
5718            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5719            .region("af-south-1".to_string())
5720            .use_dual_stack(false)
5721            .use_fips(false)
5722            .build()
5723            .expect("invalid params");
5724        let resolver = crate::config::endpoint::DefaultResolver::new();
5725        let endpoint = resolver.resolve_endpoint(&params);
5726        let error =
5727            endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@af-south-1]");
5728        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
5729    }
5730
5731    /// SDK::Host + access point ARN@af-south-1
5732    #[test]
5733    fn test_202() {
5734        let params = crate::config::endpoint::Params::builder()
5735            .accelerate(false)
5736            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5737            .force_path_style(false)
5738            .endpoint("https://beta.example.com".to_string())
5739            .region("af-south-1".to_string())
5740            .use_dual_stack(false)
5741            .use_fips(false)
5742            .build()
5743            .expect("invalid params");
5744        let resolver = crate::config::endpoint::DefaultResolver::new();
5745        let endpoint = resolver.resolve_endpoint(&params);
5746        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
5747        assert_eq!(
5748            endpoint,
5749            ::aws_smithy_types::endpoint::Endpoint::builder()
5750                .url("https://myendpoint-123456789012.beta.example.com")
5751                .property(
5752                    "authSchemes",
5753                    vec![{
5754                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5755                        out.insert("name".to_string(), "sigv4".to_string().into());
5756                        out.insert("signingName".to_string(), "s3".to_string().into());
5757                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5758                        out.insert("disableDoubleEncoding".to_string(), true.into());
5759                        out
5760                    }
5761                    .into()]
5762                )
5763                .build()
5764        );
5765    }
5766
5767    /// vanilla access point arn@us-west-2
5768    #[test]
5769    fn test_203() {
5770        let params = crate::config::endpoint::Params::builder()
5771            .accelerate(false)
5772            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5773            .force_path_style(false)
5774            .region("us-west-2".to_string())
5775            .use_dual_stack(false)
5776            .use_fips(false)
5777            .build()
5778            .expect("invalid params");
5779        let resolver = crate::config::endpoint::DefaultResolver::new();
5780        let endpoint = resolver.resolve_endpoint(&params);
5781        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
5782        assert_eq!(
5783            endpoint,
5784            ::aws_smithy_types::endpoint::Endpoint::builder()
5785                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
5786                .property(
5787                    "authSchemes",
5788                    vec![{
5789                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5790                        out.insert("name".to_string(), "sigv4".to_string().into());
5791                        out.insert("signingName".to_string(), "s3".to_string().into());
5792                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5793                        out.insert("disableDoubleEncoding".to_string(), true.into());
5794                        out
5795                    }
5796                    .into()]
5797                )
5798                .build()
5799        );
5800    }
5801
5802    /// access point arn + FIPS@us-west-2
5803    #[test]
5804    fn test_204() {
5805        let params = crate::config::endpoint::Params::builder()
5806            .accelerate(false)
5807            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5808            .force_path_style(false)
5809            .region("us-west-2".to_string())
5810            .use_dual_stack(false)
5811            .use_fips(true)
5812            .build()
5813            .expect("invalid params");
5814        let resolver = crate::config::endpoint::DefaultResolver::new();
5815        let endpoint = resolver.resolve_endpoint(&params);
5816        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.us-west-2.amazonaws.com");
5817        assert_eq!(
5818            endpoint,
5819            ::aws_smithy_types::endpoint::Endpoint::builder()
5820                .url("https://myendpoint-123456789012.s3-accesspoint-fips.us-west-2.amazonaws.com")
5821                .property(
5822                    "authSchemes",
5823                    vec![{
5824                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5825                        out.insert("name".to_string(), "sigv4".to_string().into());
5826                        out.insert("signingName".to_string(), "s3".to_string().into());
5827                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5828                        out.insert("disableDoubleEncoding".to_string(), true.into());
5829                        out
5830                    }
5831                    .into()]
5832                )
5833                .build()
5834        );
5835    }
5836
5837    /// access point arn + accelerate = error@us-west-2
5838    #[test]
5839    fn test_205() {
5840        let params = crate::config::endpoint::Params::builder()
5841            .accelerate(true)
5842            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5843            .force_path_style(false)
5844            .region("us-west-2".to_string())
5845            .use_dual_stack(false)
5846            .use_fips(false)
5847            .build()
5848            .expect("invalid params");
5849        let resolver = crate::config::endpoint::DefaultResolver::new();
5850        let endpoint = resolver.resolve_endpoint(&params);
5851        let error =
5852            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@us-west-2]");
5853        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
5854    }
5855
5856    /// access point arn + FIPS + DualStack@us-west-2
5857    #[test]
5858    fn test_206() {
5859        let params = crate::config::endpoint::Params::builder()
5860            .accelerate(false)
5861            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5862            .force_path_style(false)
5863            .region("us-west-2".to_string())
5864            .use_dual_stack(true)
5865            .use_fips(true)
5866            .build()
5867            .expect("invalid params");
5868        let resolver = crate::config::endpoint::DefaultResolver::new();
5869        let endpoint = resolver.resolve_endpoint(&params);
5870        let endpoint =
5871            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com");
5872        assert_eq!(
5873            endpoint,
5874            ::aws_smithy_types::endpoint::Endpoint::builder()
5875                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com")
5876                .property(
5877                    "authSchemes",
5878                    vec![{
5879                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5880                        out.insert("name".to_string(), "sigv4".to_string().into());
5881                        out.insert("signingName".to_string(), "s3".to_string().into());
5882                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5883                        out.insert("disableDoubleEncoding".to_string(), true.into());
5884                        out
5885                    }
5886                    .into()]
5887                )
5888                .build()
5889        );
5890    }
5891
5892    /// vanilla access point arn@cn-north-1
5893    #[test]
5894    fn test_207() {
5895        let params = crate::config::endpoint::Params::builder()
5896            .accelerate(false)
5897            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5898            .force_path_style(false)
5899            .region("cn-north-1".to_string())
5900            .use_dual_stack(false)
5901            .use_fips(false)
5902            .build()
5903            .expect("invalid params");
5904        let resolver = crate::config::endpoint::DefaultResolver::new();
5905        let endpoint = resolver.resolve_endpoint(&params);
5906        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.cn-north-1.amazonaws.com.cn");
5907        assert_eq!(
5908            endpoint,
5909            ::aws_smithy_types::endpoint::Endpoint::builder()
5910                .url("https://myendpoint-123456789012.s3-accesspoint.cn-north-1.amazonaws.com.cn")
5911                .property(
5912                    "authSchemes",
5913                    vec![{
5914                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5915                        out.insert("name".to_string(), "sigv4".to_string().into());
5916                        out.insert("signingName".to_string(), "s3".to_string().into());
5917                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5918                        out.insert("disableDoubleEncoding".to_string(), true.into());
5919                        out
5920                    }
5921                    .into()]
5922                )
5923                .build()
5924        );
5925    }
5926
5927    /// access point arn + FIPS@cn-north-1
5928    #[test]
5929    fn test_208() {
5930        let params = crate::config::endpoint::Params::builder()
5931            .accelerate(false)
5932            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5933            .force_path_style(false)
5934            .region("cn-north-1".to_string())
5935            .use_dual_stack(false)
5936            .use_fips(true)
5937            .build()
5938            .expect("invalid params");
5939        let resolver = crate::config::endpoint::DefaultResolver::new();
5940        let endpoint = resolver.resolve_endpoint(&params);
5941        let error = endpoint.expect_err("expected error: Partition does not support FIPS [access point arn + FIPS@cn-north-1]");
5942        assert_eq!(format!("{}", error), "Partition does not support FIPS")
5943    }
5944
5945    /// access point arn + accelerate = error@cn-north-1
5946    #[test]
5947    fn test_209() {
5948        let params = crate::config::endpoint::Params::builder()
5949            .accelerate(true)
5950            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5951            .force_path_style(false)
5952            .region("cn-north-1".to_string())
5953            .use_dual_stack(false)
5954            .use_fips(false)
5955            .build()
5956            .expect("invalid params");
5957        let resolver = crate::config::endpoint::DefaultResolver::new();
5958        let endpoint = resolver.resolve_endpoint(&params);
5959        let error =
5960            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@cn-north-1]");
5961        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
5962    }
5963
5964    /// access point arn + FIPS + DualStack@cn-north-1
5965    #[test]
5966    fn test_210() {
5967        let params = crate::config::endpoint::Params::builder()
5968            .accelerate(false)
5969            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5970            .force_path_style(false)
5971            .region("cn-north-1".to_string())
5972            .use_dual_stack(true)
5973            .use_fips(true)
5974            .build()
5975            .expect("invalid params");
5976        let resolver = crate::config::endpoint::DefaultResolver::new();
5977        let endpoint = resolver.resolve_endpoint(&params);
5978        let error = endpoint.expect_err("expected error: Partition does not support FIPS [access point arn + FIPS + DualStack@cn-north-1]");
5979        assert_eq!(format!("{}", error), "Partition does not support FIPS")
5980    }
5981
5982    /// vanilla access point arn@af-south-1
5983    #[test]
5984    fn test_211() {
5985        let params = crate::config::endpoint::Params::builder()
5986            .accelerate(false)
5987            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5988            .force_path_style(false)
5989            .region("af-south-1".to_string())
5990            .use_dual_stack(false)
5991            .use_fips(false)
5992            .build()
5993            .expect("invalid params");
5994        let resolver = crate::config::endpoint::DefaultResolver::new();
5995        let endpoint = resolver.resolve_endpoint(&params);
5996        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.af-south-1.amazonaws.com");
5997        assert_eq!(
5998            endpoint,
5999            ::aws_smithy_types::endpoint::Endpoint::builder()
6000                .url("https://myendpoint-123456789012.s3-accesspoint.af-south-1.amazonaws.com")
6001                .property(
6002                    "authSchemes",
6003                    vec![{
6004                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6005                        out.insert("name".to_string(), "sigv4".to_string().into());
6006                        out.insert("signingName".to_string(), "s3".to_string().into());
6007                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
6008                        out.insert("disableDoubleEncoding".to_string(), true.into());
6009                        out
6010                    }
6011                    .into()]
6012                )
6013                .build()
6014        );
6015    }
6016
6017    /// access point arn + FIPS@af-south-1
6018    #[test]
6019    fn test_212() {
6020        let params = crate::config::endpoint::Params::builder()
6021            .accelerate(false)
6022            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
6023            .force_path_style(false)
6024            .region("af-south-1".to_string())
6025            .use_dual_stack(false)
6026            .use_fips(true)
6027            .build()
6028            .expect("invalid params");
6029        let resolver = crate::config::endpoint::DefaultResolver::new();
6030        let endpoint = resolver.resolve_endpoint(&params);
6031        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.af-south-1.amazonaws.com");
6032        assert_eq!(
6033            endpoint,
6034            ::aws_smithy_types::endpoint::Endpoint::builder()
6035                .url("https://myendpoint-123456789012.s3-accesspoint-fips.af-south-1.amazonaws.com")
6036                .property(
6037                    "authSchemes",
6038                    vec![{
6039                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6040                        out.insert("name".to_string(), "sigv4".to_string().into());
6041                        out.insert("signingName".to_string(), "s3".to_string().into());
6042                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
6043                        out.insert("disableDoubleEncoding".to_string(), true.into());
6044                        out
6045                    }
6046                    .into()]
6047                )
6048                .build()
6049        );
6050    }
6051
6052    /// access point arn + accelerate = error@af-south-1
6053    #[test]
6054    fn test_213() {
6055        let params = crate::config::endpoint::Params::builder()
6056            .accelerate(true)
6057            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
6058            .force_path_style(false)
6059            .region("af-south-1".to_string())
6060            .use_dual_stack(false)
6061            .use_fips(false)
6062            .build()
6063            .expect("invalid params");
6064        let resolver = crate::config::endpoint::DefaultResolver::new();
6065        let endpoint = resolver.resolve_endpoint(&params);
6066        let error =
6067            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@af-south-1]");
6068        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
6069    }
6070
6071    /// access point arn + FIPS + DualStack@af-south-1
6072    #[test]
6073    fn test_214() {
6074        let params = crate::config::endpoint::Params::builder()
6075            .accelerate(false)
6076            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
6077            .force_path_style(false)
6078            .region("af-south-1".to_string())
6079            .use_dual_stack(true)
6080            .use_fips(true)
6081            .build()
6082            .expect("invalid params");
6083        let resolver = crate::config::endpoint::DefaultResolver::new();
6084        let endpoint = resolver.resolve_endpoint(&params);
6085        let endpoint =
6086            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.af-south-1.amazonaws.com");
6087        assert_eq!(
6088            endpoint,
6089            ::aws_smithy_types::endpoint::Endpoint::builder()
6090                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.af-south-1.amazonaws.com")
6091                .property(
6092                    "authSchemes",
6093                    vec![{
6094                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6095                        out.insert("name".to_string(), "sigv4".to_string().into());
6096                        out.insert("signingName".to_string(), "s3".to_string().into());
6097                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
6098                        out.insert("disableDoubleEncoding".to_string(), true.into());
6099                        out
6100                    }
6101                    .into()]
6102                )
6103                .build()
6104        );
6105    }
6106
6107    /// S3 outposts vanilla test
6108    #[test]
6109    fn test_215() {
6110        let params = crate::config::endpoint::Params::builder()
6111            .region("us-west-2".to_string())
6112            .use_fips(false)
6113            .use_dual_stack(false)
6114            .accelerate(false)
6115            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6116            .build()
6117            .expect("invalid params");
6118        let resolver = crate::config::endpoint::DefaultResolver::new();
6119        let endpoint = resolver.resolve_endpoint(&params);
6120        let endpoint =
6121            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-west-2.amazonaws.com");
6122        assert_eq!(
6123            endpoint,
6124            ::aws_smithy_types::endpoint::Endpoint::builder()
6125                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-west-2.amazonaws.com")
6126                .property(
6127                    "authSchemes",
6128                    vec![
6129                        {
6130                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6131                            out.insert("name".to_string(), "sigv4a".to_string().into());
6132                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6133                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
6134                            out.insert("disableDoubleEncoding".to_string(), true.into());
6135                            out
6136                        }
6137                        .into(),
6138                        {
6139                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6140                            out.insert("name".to_string(), "sigv4".to_string().into());
6141                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6142                            out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6143                            out.insert("disableDoubleEncoding".to_string(), true.into());
6144                            out
6145                        }
6146                        .into()
6147                    ]
6148                )
6149                .build()
6150        );
6151    }
6152
6153    /// S3 outposts custom endpoint
6154    #[test]
6155    fn test_216() {
6156        let params = crate::config::endpoint::Params::builder()
6157            .region("us-west-2".to_string())
6158            .use_fips(false)
6159            .use_dual_stack(false)
6160            .accelerate(false)
6161            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6162            .endpoint("https://example.amazonaws.com".to_string())
6163            .build()
6164            .expect("invalid params");
6165        let resolver = crate::config::endpoint::DefaultResolver::new();
6166        let endpoint = resolver.resolve_endpoint(&params);
6167        let endpoint = endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.example.amazonaws.com");
6168        assert_eq!(
6169            endpoint,
6170            ::aws_smithy_types::endpoint::Endpoint::builder()
6171                .url("https://reports-123456789012.op-01234567890123456.example.amazonaws.com")
6172                .property(
6173                    "authSchemes",
6174                    vec![
6175                        {
6176                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6177                            out.insert("name".to_string(), "sigv4a".to_string().into());
6178                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6179                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
6180                            out.insert("disableDoubleEncoding".to_string(), true.into());
6181                            out
6182                        }
6183                        .into(),
6184                        {
6185                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6186                            out.insert("name".to_string(), "sigv4".to_string().into());
6187                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6188                            out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6189                            out.insert("disableDoubleEncoding".to_string(), true.into());
6190                            out
6191                        }
6192                        .into()
6193                    ]
6194                )
6195                .build()
6196        );
6197    }
6198
6199    /// outposts arn with region mismatch and UseArnRegion=false
6200    #[test]
6201    fn test_217() {
6202        let params = crate::config::endpoint::Params::builder()
6203            .accelerate(false)
6204            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6205            .force_path_style(false)
6206            .use_arn_region(false)
6207            .region("us-west-2".to_string())
6208            .use_dual_stack(false)
6209            .use_fips(false)
6210            .build()
6211            .expect("invalid params");
6212        let resolver = crate::config::endpoint::DefaultResolver::new();
6213        let endpoint = resolver.resolve_endpoint(&params);
6214        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]");
6215        assert_eq!(
6216            format!("{}", error),
6217            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
6218        )
6219    }
6220
6221    /// outposts arn with region mismatch, custom region and UseArnRegion=false
6222    #[test]
6223    fn test_218() {
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            .endpoint("https://example.com".to_string())
6228            .force_path_style(false)
6229            .use_arn_region(false)
6230            .region("us-west-2".to_string())
6231            .use_dual_stack(false)
6232            .use_fips(false)
6233            .build()
6234            .expect("invalid params");
6235        let resolver = crate::config::endpoint::DefaultResolver::new();
6236        let endpoint = resolver.resolve_endpoint(&params);
6237        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]");
6238        assert_eq!(
6239            format!("{}", error),
6240            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
6241        )
6242    }
6243
6244    /// outposts arn with region mismatch and UseArnRegion=true
6245    #[test]
6246    fn test_219() {
6247        let params = crate::config::endpoint::Params::builder()
6248            .accelerate(false)
6249            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6250            .force_path_style(false)
6251            .use_arn_region(true)
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 endpoint =
6260            endpoint.expect("Expected valid endpoint: https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
6261        assert_eq!(
6262            endpoint,
6263            ::aws_smithy_types::endpoint::Endpoint::builder()
6264                .url("https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
6265                .property(
6266                    "authSchemes",
6267                    vec![
6268                        {
6269                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6270                            out.insert("name".to_string(), "sigv4a".to_string().into());
6271                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6272                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
6273                            out.insert("disableDoubleEncoding".to_string(), true.into());
6274                            out
6275                        }
6276                        .into(),
6277                        {
6278                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6279                            out.insert("name".to_string(), "sigv4".to_string().into());
6280                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6281                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6282                            out.insert("disableDoubleEncoding".to_string(), true.into());
6283                            out
6284                        }
6285                        .into()
6286                    ]
6287                )
6288                .build()
6289        );
6290    }
6291
6292    /// outposts arn with region mismatch and UseArnRegion unset
6293    #[test]
6294    fn test_220() {
6295        let params = crate::config::endpoint::Params::builder()
6296            .accelerate(false)
6297            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6298            .force_path_style(false)
6299            .region("us-west-2".to_string())
6300            .use_dual_stack(false)
6301            .use_fips(false)
6302            .build()
6303            .expect("invalid params");
6304        let resolver = crate::config::endpoint::DefaultResolver::new();
6305        let endpoint = resolver.resolve_endpoint(&params);
6306        let endpoint =
6307            endpoint.expect("Expected valid endpoint: https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
6308        assert_eq!(
6309            endpoint,
6310            ::aws_smithy_types::endpoint::Endpoint::builder()
6311                .url("https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
6312                .property(
6313                    "authSchemes",
6314                    vec![
6315                        {
6316                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6317                            out.insert("name".to_string(), "sigv4a".to_string().into());
6318                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6319                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
6320                            out.insert("disableDoubleEncoding".to_string(), true.into());
6321                            out
6322                        }
6323                        .into(),
6324                        {
6325                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6326                            out.insert("name".to_string(), "sigv4".to_string().into());
6327                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6328                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6329                            out.insert("disableDoubleEncoding".to_string(), true.into());
6330                            out
6331                        }
6332                        .into()
6333                    ]
6334                )
6335                .build()
6336        );
6337    }
6338
6339    /// outposts arn with partition mismatch and UseArnRegion=true
6340    #[test]
6341    fn test_221() {
6342        let params = crate::config::endpoint::Params::builder()
6343            .accelerate(false)
6344            .bucket("arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6345            .force_path_style(false)
6346            .use_arn_region(true)
6347            .region("us-west-2".to_string())
6348            .use_dual_stack(false)
6349            .use_fips(false)
6350            .build()
6351            .expect("invalid params");
6352        let resolver = crate::config::endpoint::DefaultResolver::new();
6353        let endpoint = resolver.resolve_endpoint(&params);
6354        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]");
6355        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`")
6356    }
6357
6358    /// ARN with UseGlobalEndpoint and use-east-1 region uses the regional endpoint
6359    #[test]
6360    fn test_222() {
6361        let params = crate::config::endpoint::Params::builder()
6362            .region("us-east-1".to_string())
6363            .use_global_endpoint(true)
6364            .use_fips(false)
6365            .use_dual_stack(false)
6366            .accelerate(false)
6367            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6368            .build()
6369            .expect("invalid params");
6370        let resolver = crate::config::endpoint::DefaultResolver::new();
6371        let endpoint = resolver.resolve_endpoint(&params);
6372        let endpoint =
6373            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
6374        assert_eq!(
6375            endpoint,
6376            ::aws_smithy_types::endpoint::Endpoint::builder()
6377                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
6378                .property(
6379                    "authSchemes",
6380                    vec![
6381                        {
6382                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6383                            out.insert("name".to_string(), "sigv4a".to_string().into());
6384                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6385                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
6386                            out.insert("disableDoubleEncoding".to_string(), true.into());
6387                            out
6388                        }
6389                        .into(),
6390                        {
6391                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6392                            out.insert("name".to_string(), "sigv4".to_string().into());
6393                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6394                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6395                            out.insert("disableDoubleEncoding".to_string(), true.into());
6396                            out
6397                        }
6398                        .into()
6399                    ]
6400                )
6401                .build()
6402        );
6403    }
6404
6405    /// S3 outposts does not support dualstack
6406    #[test]
6407    fn test_223() {
6408        let params = crate::config::endpoint::Params::builder()
6409            .region("us-east-1".to_string())
6410            .use_fips(false)
6411            .use_dual_stack(true)
6412            .accelerate(false)
6413            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6414            .build()
6415            .expect("invalid params");
6416        let resolver = crate::config::endpoint::DefaultResolver::new();
6417        let endpoint = resolver.resolve_endpoint(&params);
6418        let error = endpoint.expect_err("expected error: S3 Outposts does not support Dual-stack [S3 outposts does not support dualstack]");
6419        assert_eq!(format!("{}", error), "S3 Outposts does not support Dual-stack")
6420    }
6421
6422    /// S3 outposts does not support fips
6423    #[test]
6424    fn test_224() {
6425        let params = crate::config::endpoint::Params::builder()
6426            .region("us-east-1".to_string())
6427            .use_fips(true)
6428            .use_dual_stack(false)
6429            .accelerate(false)
6430            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6431            .build()
6432            .expect("invalid params");
6433        let resolver = crate::config::endpoint::DefaultResolver::new();
6434        let endpoint = resolver.resolve_endpoint(&params);
6435        let error = endpoint.expect_err("expected error: S3 Outposts does not support FIPS [S3 outposts does not support fips]");
6436        assert_eq!(format!("{}", error), "S3 Outposts does not support FIPS")
6437    }
6438
6439    /// S3 outposts does not support accelerate
6440    #[test]
6441    fn test_225() {
6442        let params = crate::config::endpoint::Params::builder()
6443            .region("us-east-1".to_string())
6444            .use_fips(false)
6445            .use_dual_stack(false)
6446            .accelerate(true)
6447            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6448            .build()
6449            .expect("invalid params");
6450        let resolver = crate::config::endpoint::DefaultResolver::new();
6451        let endpoint = resolver.resolve_endpoint(&params);
6452        let error = endpoint.expect_err("expected error: S3 Outposts does not support S3 Accelerate [S3 outposts does not support accelerate]");
6453        assert_eq!(format!("{}", error), "S3 Outposts does not support S3 Accelerate")
6454    }
6455
6456    /// validates against subresource
6457    #[test]
6458    fn test_226() {
6459        let params = crate::config::endpoint::Params::builder()
6460            .region("us-west-2".to_string())
6461            .use_fips(false)
6462            .use_dual_stack(false)
6463            .accelerate(false)
6464            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:mybucket:object:foo".to_string())
6465            .build()
6466            .expect("invalid params");
6467        let resolver = crate::config::endpoint::DefaultResolver::new();
6468        let endpoint = resolver.resolve_endpoint(&params);
6469        let error =
6470            endpoint.expect_err("expected error: Invalid Arn: Outpost Access Point ARN contains sub resources [validates against subresource]");
6471        assert_eq!(format!("{}", error), "Invalid Arn: Outpost Access Point ARN contains sub resources")
6472    }
6473
6474    /// object lambda @us-east-1
6475    #[test]
6476    fn test_227() {
6477        let params = crate::config::endpoint::Params::builder()
6478            .region("us-east-1".to_string())
6479            .use_fips(false)
6480            .use_dual_stack(false)
6481            .accelerate(false)
6482            .use_arn_region(false)
6483            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6484            .build()
6485            .expect("invalid params");
6486        let resolver = crate::config::endpoint::DefaultResolver::new();
6487        let endpoint = resolver.resolve_endpoint(&params);
6488        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
6489        assert_eq!(
6490            endpoint,
6491            ::aws_smithy_types::endpoint::Endpoint::builder()
6492                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
6493                .property(
6494                    "authSchemes",
6495                    vec![{
6496                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6497                        out.insert("name".to_string(), "sigv4".to_string().into());
6498                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6499                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6500                        out.insert("disableDoubleEncoding".to_string(), true.into());
6501                        out
6502                    }
6503                    .into()]
6504                )
6505                .build()
6506        );
6507    }
6508
6509    /// object lambda @us-west-2
6510    #[test]
6511    fn test_228() {
6512        let params = crate::config::endpoint::Params::builder()
6513            .region("us-west-2".to_string())
6514            .use_fips(false)
6515            .use_dual_stack(false)
6516            .accelerate(false)
6517            .use_arn_region(false)
6518            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
6519            .build()
6520            .expect("invalid params");
6521        let resolver = crate::config::endpoint::DefaultResolver::new();
6522        let endpoint = resolver.resolve_endpoint(&params);
6523        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com");
6524        assert_eq!(
6525            endpoint,
6526            ::aws_smithy_types::endpoint::Endpoint::builder()
6527                .url("https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com")
6528                .property(
6529                    "authSchemes",
6530                    vec![{
6531                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6532                        out.insert("name".to_string(), "sigv4".to_string().into());
6533                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6534                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6535                        out.insert("disableDoubleEncoding".to_string(), true.into());
6536                        out
6537                    }
6538                    .into()]
6539                )
6540                .build()
6541        );
6542    }
6543
6544    /// object lambda, colon resource deliminator @us-west-2
6545    #[test]
6546    fn test_229() {
6547        let params = crate::config::endpoint::Params::builder()
6548            .region("us-west-2".to_string())
6549            .use_fips(false)
6550            .use_dual_stack(false)
6551            .accelerate(false)
6552            .use_arn_region(false)
6553            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:mybanner".to_string())
6554            .build()
6555            .expect("invalid params");
6556        let resolver = crate::config::endpoint::DefaultResolver::new();
6557        let endpoint = resolver.resolve_endpoint(&params);
6558        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com");
6559        assert_eq!(
6560            endpoint,
6561            ::aws_smithy_types::endpoint::Endpoint::builder()
6562                .url("https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com")
6563                .property(
6564                    "authSchemes",
6565                    vec![{
6566                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6567                        out.insert("name".to_string(), "sigv4".to_string().into());
6568                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6569                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6570                        out.insert("disableDoubleEncoding".to_string(), true.into());
6571                        out
6572                    }
6573                    .into()]
6574                )
6575                .build()
6576        );
6577    }
6578
6579    /// object lambda @us-east-1, client region us-west-2, useArnRegion=true
6580    #[test]
6581    fn test_230() {
6582        let params = crate::config::endpoint::Params::builder()
6583            .region("us-west-2".to_string())
6584            .use_fips(false)
6585            .use_dual_stack(false)
6586            .accelerate(false)
6587            .use_arn_region(true)
6588            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6589            .build()
6590            .expect("invalid params");
6591        let resolver = crate::config::endpoint::DefaultResolver::new();
6592        let endpoint = resolver.resolve_endpoint(&params);
6593        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
6594        assert_eq!(
6595            endpoint,
6596            ::aws_smithy_types::endpoint::Endpoint::builder()
6597                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
6598                .property(
6599                    "authSchemes",
6600                    vec![{
6601                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6602                        out.insert("name".to_string(), "sigv4".to_string().into());
6603                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6604                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6605                        out.insert("disableDoubleEncoding".to_string(), true.into());
6606                        out
6607                    }
6608                    .into()]
6609                )
6610                .build()
6611        );
6612    }
6613
6614    /// object lambda @us-east-1, client region s3-external-1, useArnRegion=true
6615    #[test]
6616    fn test_231() {
6617        let params = crate::config::endpoint::Params::builder()
6618            .region("s3-external-1".to_string())
6619            .use_fips(false)
6620            .use_dual_stack(false)
6621            .accelerate(false)
6622            .use_arn_region(true)
6623            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6624            .build()
6625            .expect("invalid params");
6626        let resolver = crate::config::endpoint::DefaultResolver::new();
6627        let endpoint = resolver.resolve_endpoint(&params);
6628        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
6629        assert_eq!(
6630            endpoint,
6631            ::aws_smithy_types::endpoint::Endpoint::builder()
6632                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
6633                .property(
6634                    "authSchemes",
6635                    vec![{
6636                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6637                        out.insert("name".to_string(), "sigv4".to_string().into());
6638                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6639                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6640                        out.insert("disableDoubleEncoding".to_string(), true.into());
6641                        out
6642                    }
6643                    .into()]
6644                )
6645                .build()
6646        );
6647    }
6648
6649    /// object lambda @us-east-1, client region s3-external-1, useArnRegion=false
6650    #[test]
6651    fn test_232() {
6652        let params = crate::config::endpoint::Params::builder()
6653            .region("s3-external-1".to_string())
6654            .use_fips(false)
6655            .use_dual_stack(false)
6656            .accelerate(false)
6657            .use_arn_region(false)
6658            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6659            .build()
6660            .expect("invalid params");
6661        let resolver = crate::config::endpoint::DefaultResolver::new();
6662        let endpoint = resolver.resolve_endpoint(&params);
6663        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]");
6664        assert_eq!(
6665            format!("{}", error),
6666            "Invalid configuration: region from ARN `us-east-1` does not match client region `s3-external-1` and UseArnRegion is `false`"
6667        )
6668    }
6669
6670    /// object lambda @us-east-1, client region aws-global, useArnRegion=true
6671    #[test]
6672    fn test_233() {
6673        let params = crate::config::endpoint::Params::builder()
6674            .region("aws-global".to_string())
6675            .use_fips(false)
6676            .use_dual_stack(false)
6677            .accelerate(false)
6678            .use_arn_region(true)
6679            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6680            .build()
6681            .expect("invalid params");
6682        let resolver = crate::config::endpoint::DefaultResolver::new();
6683        let endpoint = resolver.resolve_endpoint(&params);
6684        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
6685        assert_eq!(
6686            endpoint,
6687            ::aws_smithy_types::endpoint::Endpoint::builder()
6688                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
6689                .property(
6690                    "authSchemes",
6691                    vec![{
6692                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6693                        out.insert("name".to_string(), "sigv4".to_string().into());
6694                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6695                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6696                        out.insert("disableDoubleEncoding".to_string(), true.into());
6697                        out
6698                    }
6699                    .into()]
6700                )
6701                .build()
6702        );
6703    }
6704
6705    /// object lambda @us-east-1, client region aws-global, useArnRegion=false
6706    #[test]
6707    fn test_234() {
6708        let params = crate::config::endpoint::Params::builder()
6709            .region("aws-global".to_string())
6710            .use_fips(false)
6711            .use_dual_stack(false)
6712            .accelerate(false)
6713            .use_arn_region(false)
6714            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6715            .build()
6716            .expect("invalid params");
6717        let resolver = crate::config::endpoint::DefaultResolver::new();
6718        let endpoint = resolver.resolve_endpoint(&params);
6719        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]");
6720        assert_eq!(
6721            format!("{}", error),
6722            "Invalid configuration: region from ARN `us-east-1` does not match client region `aws-global` and UseArnRegion is `false`"
6723        )
6724    }
6725
6726    /// object lambda @cn-north-1, client region us-west-2 (cross partition), useArnRegion=true
6727    #[test]
6728    fn test_235() {
6729        let params = crate::config::endpoint::Params::builder()
6730            .region("aws-global".to_string())
6731            .use_fips(false)
6732            .use_dual_stack(false)
6733            .accelerate(false)
6734            .use_arn_region(true)
6735            .bucket("arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner".to_string())
6736            .build()
6737            .expect("invalid params");
6738        let resolver = crate::config::endpoint::DefaultResolver::new();
6739        let endpoint = resolver.resolve_endpoint(&params);
6740        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]");
6741        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`")
6742    }
6743
6744    /// object lambda with dualstack
6745    #[test]
6746    fn test_236() {
6747        let params = crate::config::endpoint::Params::builder()
6748            .region("us-west-2".to_string())
6749            .use_fips(false)
6750            .use_dual_stack(true)
6751            .accelerate(false)
6752            .use_arn_region(false)
6753            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
6754            .build()
6755            .expect("invalid params");
6756        let resolver = crate::config::endpoint::DefaultResolver::new();
6757        let endpoint = resolver.resolve_endpoint(&params);
6758        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support Dual-stack [object lambda with dualstack]");
6759        assert_eq!(format!("{}", error), "S3 Object Lambda does not support Dual-stack")
6760    }
6761
6762    /// object lambda @us-gov-east-1
6763    #[test]
6764    fn test_237() {
6765        let params = crate::config::endpoint::Params::builder()
6766            .region("us-gov-east-1".to_string())
6767            .use_fips(false)
6768            .use_dual_stack(false)
6769            .accelerate(false)
6770            .use_arn_region(false)
6771            .bucket("arn:aws-us-gov:s3-object-lambda:us-gov-east-1:123456789012:accesspoint/mybanner".to_string())
6772            .build()
6773            .expect("invalid params");
6774        let resolver = crate::config::endpoint::DefaultResolver::new();
6775        let endpoint = resolver.resolve_endpoint(&params);
6776        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-gov-east-1.amazonaws.com");
6777        assert_eq!(
6778            endpoint,
6779            ::aws_smithy_types::endpoint::Endpoint::builder()
6780                .url("https://mybanner-123456789012.s3-object-lambda.us-gov-east-1.amazonaws.com")
6781                .property(
6782                    "authSchemes",
6783                    vec![{
6784                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6785                        out.insert("name".to_string(), "sigv4".to_string().into());
6786                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6787                        out.insert("signingRegion".to_string(), "us-gov-east-1".to_string().into());
6788                        out.insert("disableDoubleEncoding".to_string(), true.into());
6789                        out
6790                    }
6791                    .into()]
6792                )
6793                .build()
6794        );
6795    }
6796
6797    /// object lambda @us-gov-east-1, with fips
6798    #[test]
6799    fn test_238() {
6800        let params = crate::config::endpoint::Params::builder()
6801            .region("us-gov-east-1".to_string())
6802            .use_fips(true)
6803            .use_dual_stack(false)
6804            .accelerate(false)
6805            .use_arn_region(false)
6806            .bucket("arn:aws-us-gov:s3-object-lambda:us-gov-east-1:123456789012:accesspoint/mybanner".to_string())
6807            .build()
6808            .expect("invalid params");
6809        let resolver = crate::config::endpoint::DefaultResolver::new();
6810        let endpoint = resolver.resolve_endpoint(&params);
6811        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda-fips.us-gov-east-1.amazonaws.com");
6812        assert_eq!(
6813            endpoint,
6814            ::aws_smithy_types::endpoint::Endpoint::builder()
6815                .url("https://mybanner-123456789012.s3-object-lambda-fips.us-gov-east-1.amazonaws.com")
6816                .property(
6817                    "authSchemes",
6818                    vec![{
6819                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6820                        out.insert("name".to_string(), "sigv4".to_string().into());
6821                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6822                        out.insert("signingRegion".to_string(), "us-gov-east-1".to_string().into());
6823                        out.insert("disableDoubleEncoding".to_string(), true.into());
6824                        out
6825                    }
6826                    .into()]
6827                )
6828                .build()
6829        );
6830    }
6831
6832    /// object lambda @cn-north-1, with fips
6833    #[test]
6834    fn test_239() {
6835        let params = crate::config::endpoint::Params::builder()
6836            .region("cn-north-1".to_string())
6837            .use_fips(true)
6838            .use_dual_stack(false)
6839            .accelerate(false)
6840            .use_arn_region(false)
6841            .bucket("arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner".to_string())
6842            .build()
6843            .expect("invalid params");
6844        let resolver = crate::config::endpoint::DefaultResolver::new();
6845        let endpoint = resolver.resolve_endpoint(&params);
6846        let error = endpoint.expect_err("expected error: Partition does not support FIPS [object lambda @cn-north-1, with fips]");
6847        assert_eq!(format!("{}", error), "Partition does not support FIPS")
6848    }
6849
6850    /// object lambda with accelerate
6851    #[test]
6852    fn test_240() {
6853        let params = crate::config::endpoint::Params::builder()
6854            .region("us-west-2".to_string())
6855            .use_fips(false)
6856            .use_dual_stack(false)
6857            .accelerate(true)
6858            .use_arn_region(false)
6859            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
6860            .build()
6861            .expect("invalid params");
6862        let resolver = crate::config::endpoint::DefaultResolver::new();
6863        let endpoint = resolver.resolve_endpoint(&params);
6864        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support S3 Accelerate [object lambda with accelerate]");
6865        assert_eq!(format!("{}", error), "S3 Object Lambda does not support S3 Accelerate")
6866    }
6867
6868    /// object lambda with invalid arn - bad service and someresource
6869    #[test]
6870    fn test_241() {
6871        let params = crate::config::endpoint::Params::builder()
6872            .region("us-west-2".to_string())
6873            .use_fips(false)
6874            .use_dual_stack(false)
6875            .accelerate(false)
6876            .use_arn_region(false)
6877            .bucket("arn:aws:sqs:us-west-2:123456789012:someresource".to_string())
6878            .build()
6879            .expect("invalid params");
6880        let resolver = crate::config::endpoint::DefaultResolver::new();
6881        let endpoint = resolver.resolve_endpoint(&params);
6882        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]");
6883        assert_eq!(
6884            format!("{}", error),
6885            "Invalid ARN: Unrecognized format: arn:aws:sqs:us-west-2:123456789012:someresource (type: someresource)"
6886        )
6887    }
6888
6889    /// object lambda with invalid arn - invalid resource
6890    #[test]
6891    fn test_242() {
6892        let params = crate::config::endpoint::Params::builder()
6893            .region("us-west-2".to_string())
6894            .use_fips(false)
6895            .use_dual_stack(false)
6896            .accelerate(false)
6897            .use_arn_region(false)
6898            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:bucket_name:mybucket".to_string())
6899            .build()
6900            .expect("invalid params");
6901        let resolver = crate::config::endpoint::DefaultResolver::new();
6902        let endpoint = resolver.resolve_endpoint(&params);
6903        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]");
6904        assert_eq!(
6905            format!("{}", error),
6906            "Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `bucket_name`"
6907        )
6908    }
6909
6910    /// object lambda with invalid arn - missing region
6911    #[test]
6912    fn test_243() {
6913        let params = crate::config::endpoint::Params::builder()
6914            .region("us-west-2".to_string())
6915            .use_fips(false)
6916            .use_dual_stack(false)
6917            .accelerate(false)
6918            .use_arn_region(false)
6919            .bucket("arn:aws:s3-object-lambda::123456789012:accesspoint/mybanner".to_string())
6920            .build()
6921            .expect("invalid params");
6922        let resolver = crate::config::endpoint::DefaultResolver::new();
6923        let endpoint = resolver.resolve_endpoint(&params);
6924        let error =
6925            endpoint.expect_err("expected error: Invalid ARN: bucket ARN is missing a region [object lambda with invalid arn - missing region]");
6926        assert_eq!(format!("{}", error), "Invalid ARN: bucket ARN is missing a region")
6927    }
6928
6929    /// object lambda with invalid arn - missing account-id
6930    #[test]
6931    fn test_244() {
6932        let params = crate::config::endpoint::Params::builder()
6933            .region("us-west-2".to_string())
6934            .use_fips(false)
6935            .use_dual_stack(false)
6936            .accelerate(false)
6937            .use_arn_region(true)
6938            .bucket("arn:aws:s3-object-lambda:us-west-2::accesspoint/mybanner".to_string())
6939            .build()
6940            .expect("invalid params");
6941        let resolver = crate::config::endpoint::DefaultResolver::new();
6942        let endpoint = resolver.resolve_endpoint(&params);
6943        let error = endpoint.expect_err("expected error: Invalid ARN: Missing account id [object lambda with invalid arn - missing account-id]");
6944        assert_eq!(format!("{}", error), "Invalid ARN: Missing account id")
6945    }
6946
6947    /// object lambda with invalid arn - account id contains invalid characters
6948    #[test]
6949    fn test_245() {
6950        let params = crate::config::endpoint::Params::builder()
6951            .region("us-west-2".to_string())
6952            .use_fips(false)
6953            .use_dual_stack(false)
6954            .accelerate(false)
6955            .use_arn_region(true)
6956            .bucket("arn:aws:s3-object-lambda:us-west-2:123.45678.9012:accesspoint:mybucket".to_string())
6957            .build()
6958            .expect("invalid params");
6959        let resolver = crate::config::endpoint::DefaultResolver::new();
6960        let endpoint = resolver.resolve_endpoint(&params);
6961        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]");
6962        assert_eq!(
6963            format!("{}", error),
6964            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123.45678.9012`"
6965        )
6966    }
6967
6968    /// object lambda with invalid arn - missing access point name
6969    #[test]
6970    fn test_246() {
6971        let params = crate::config::endpoint::Params::builder()
6972            .region("us-west-2".to_string())
6973            .use_fips(false)
6974            .use_dual_stack(false)
6975            .accelerate(false)
6976            .use_arn_region(true)
6977            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint".to_string())
6978            .build()
6979            .expect("invalid params");
6980        let resolver = crate::config::endpoint::DefaultResolver::new();
6981        let endpoint = resolver.resolve_endpoint(&params);
6982        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]");
6983        assert_eq!(
6984            format!("{}", error),
6985            "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided"
6986        )
6987    }
6988
6989    /// object lambda with invalid arn - access point name contains invalid character: *
6990    #[test]
6991    fn test_247() {
6992        let params = crate::config::endpoint::Params::builder()
6993            .region("us-west-2".to_string())
6994            .use_fips(false)
6995            .use_dual_stack(false)
6996            .accelerate(false)
6997            .use_arn_region(true)
6998            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:*".to_string())
6999            .build()
7000            .expect("invalid params");
7001        let resolver = crate::config::endpoint::DefaultResolver::new();
7002        let endpoint = resolver.resolve_endpoint(&params);
7003        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: *]");
7004        assert_eq!(
7005            format!("{}", error),
7006            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `*`"
7007        )
7008    }
7009
7010    /// object lambda with invalid arn - access point name contains invalid character: .
7011    #[test]
7012    fn test_248() {
7013        let params = crate::config::endpoint::Params::builder()
7014            .region("us-west-2".to_string())
7015            .use_fips(false)
7016            .use_dual_stack(false)
7017            .accelerate(false)
7018            .use_arn_region(true)
7019            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:my.bucket".to_string())
7020            .build()
7021            .expect("invalid params");
7022        let resolver = crate::config::endpoint::DefaultResolver::new();
7023        let endpoint = resolver.resolve_endpoint(&params);
7024        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: .]");
7025        assert_eq!(
7026            format!("{}", error),
7027            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `my.bucket`"
7028        )
7029    }
7030
7031    /// object lambda with invalid arn - access point name contains sub resources
7032    #[test]
7033    fn test_249() {
7034        let params = crate::config::endpoint::Params::builder()
7035            .region("us-west-2".to_string())
7036            .use_fips(false)
7037            .use_dual_stack(false)
7038            .accelerate(false)
7039            .use_arn_region(true)
7040            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:mybucket:object:foo".to_string())
7041            .build()
7042            .expect("invalid params");
7043        let resolver = crate::config::endpoint::DefaultResolver::new();
7044        let endpoint = resolver.resolve_endpoint(&params);
7045        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]");
7046        assert_eq!(
7047            format!("{}", error),
7048            "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`."
7049        )
7050    }
7051
7052    /// object lambda with custom endpoint
7053    #[test]
7054    fn test_250() {
7055        let params = crate::config::endpoint::Params::builder()
7056            .region("us-west-2".to_string())
7057            .use_fips(false)
7058            .use_dual_stack(false)
7059            .accelerate(false)
7060            .use_arn_region(false)
7061            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
7062            .endpoint("https://my-endpoint.com".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 endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.my-endpoint.com");
7068        assert_eq!(
7069            endpoint,
7070            ::aws_smithy_types::endpoint::Endpoint::builder()
7071                .url("https://mybanner-123456789012.my-endpoint.com")
7072                .property(
7073                    "authSchemes",
7074                    vec![{
7075                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7076                        out.insert("name".to_string(), "sigv4".to_string().into());
7077                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7078                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7079                        out.insert("disableDoubleEncoding".to_string(), true.into());
7080                        out
7081                    }
7082                    .into()]
7083                )
7084                .build()
7085        );
7086    }
7087
7088    /// object lambda arn with region mismatch and UseArnRegion=false
7089    #[test]
7090    fn test_251() {
7091        let params = crate::config::endpoint::Params::builder()
7092            .accelerate(false)
7093            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
7094            .force_path_style(false)
7095            .use_arn_region(false)
7096            .region("us-west-2".to_string())
7097            .use_dual_stack(false)
7098            .use_fips(false)
7099            .build()
7100            .expect("invalid params");
7101        let resolver = crate::config::endpoint::DefaultResolver::new();
7102        let endpoint = resolver.resolve_endpoint(&params);
7103        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]");
7104        assert_eq!(
7105            format!("{}", error),
7106            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
7107        )
7108    }
7109
7110    /// WriteGetObjectResponse @ us-west-2
7111    #[test]
7112    fn test_252() {
7113        let params = crate::config::endpoint::Params::builder()
7114            .accelerate(false)
7115            .use_object_lambda_endpoint(true)
7116            .region("us-west-2".to_string())
7117            .use_dual_stack(false)
7118            .use_fips(false)
7119            .build()
7120            .expect("invalid params");
7121        let resolver = crate::config::endpoint::DefaultResolver::new();
7122        let endpoint = resolver.resolve_endpoint(&params);
7123        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-west-2.amazonaws.com");
7124        assert_eq!(
7125            endpoint,
7126            ::aws_smithy_types::endpoint::Endpoint::builder()
7127                .url("https://s3-object-lambda.us-west-2.amazonaws.com")
7128                .property(
7129                    "authSchemes",
7130                    vec![{
7131                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7132                        out.insert("name".to_string(), "sigv4".to_string().into());
7133                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7134                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7135                        out.insert("disableDoubleEncoding".to_string(), true.into());
7136                        out
7137                    }
7138                    .into()]
7139                )
7140                .build()
7141        );
7142    }
7143
7144    /// WriteGetObjectResponse with custom endpoint
7145    #[test]
7146    fn test_253() {
7147        let params = crate::config::endpoint::Params::builder()
7148            .accelerate(false)
7149            .use_object_lambda_endpoint(true)
7150            .endpoint("https://my-endpoint.com".to_string())
7151            .region("us-west-2".to_string())
7152            .use_dual_stack(false)
7153            .use_fips(false)
7154            .build()
7155            .expect("invalid params");
7156        let resolver = crate::config::endpoint::DefaultResolver::new();
7157        let endpoint = resolver.resolve_endpoint(&params);
7158        let endpoint = endpoint.expect("Expected valid endpoint: https://my-endpoint.com");
7159        assert_eq!(
7160            endpoint,
7161            ::aws_smithy_types::endpoint::Endpoint::builder()
7162                .url("https://my-endpoint.com")
7163                .property(
7164                    "authSchemes",
7165                    vec![{
7166                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7167                        out.insert("name".to_string(), "sigv4".to_string().into());
7168                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7169                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7170                        out.insert("disableDoubleEncoding".to_string(), true.into());
7171                        out
7172                    }
7173                    .into()]
7174                )
7175                .build()
7176        );
7177    }
7178
7179    /// WriteGetObjectResponse @ us-east-1
7180    #[test]
7181    fn test_254() {
7182        let params = crate::config::endpoint::Params::builder()
7183            .accelerate(false)
7184            .use_object_lambda_endpoint(true)
7185            .region("us-east-1".to_string())
7186            .use_dual_stack(false)
7187            .use_fips(false)
7188            .build()
7189            .expect("invalid params");
7190        let resolver = crate::config::endpoint::DefaultResolver::new();
7191        let endpoint = resolver.resolve_endpoint(&params);
7192        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-east-1.amazonaws.com");
7193        assert_eq!(
7194            endpoint,
7195            ::aws_smithy_types::endpoint::Endpoint::builder()
7196                .url("https://s3-object-lambda.us-east-1.amazonaws.com")
7197                .property(
7198                    "authSchemes",
7199                    vec![{
7200                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7201                        out.insert("name".to_string(), "sigv4".to_string().into());
7202                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7203                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7204                        out.insert("disableDoubleEncoding".to_string(), true.into());
7205                        out
7206                    }
7207                    .into()]
7208                )
7209                .build()
7210        );
7211    }
7212
7213    /// WriteGetObjectResponse with fips
7214    #[test]
7215    fn test_255() {
7216        let params = crate::config::endpoint::Params::builder()
7217            .accelerate(false)
7218            .use_object_lambda_endpoint(true)
7219            .region("us-east-1".to_string())
7220            .use_dual_stack(false)
7221            .use_fips(true)
7222            .build()
7223            .expect("invalid params");
7224        let resolver = crate::config::endpoint::DefaultResolver::new();
7225        let endpoint = resolver.resolve_endpoint(&params);
7226        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda-fips.us-east-1.amazonaws.com");
7227        assert_eq!(
7228            endpoint,
7229            ::aws_smithy_types::endpoint::Endpoint::builder()
7230                .url("https://s3-object-lambda-fips.us-east-1.amazonaws.com")
7231                .property(
7232                    "authSchemes",
7233                    vec![{
7234                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7235                        out.insert("name".to_string(), "sigv4".to_string().into());
7236                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7237                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7238                        out.insert("disableDoubleEncoding".to_string(), true.into());
7239                        out
7240                    }
7241                    .into()]
7242                )
7243                .build()
7244        );
7245    }
7246
7247    /// WriteGetObjectResponse with dualstack
7248    #[test]
7249    fn test_256() {
7250        let params = crate::config::endpoint::Params::builder()
7251            .accelerate(false)
7252            .use_object_lambda_endpoint(true)
7253            .region("us-east-1".to_string())
7254            .use_dual_stack(true)
7255            .use_fips(false)
7256            .build()
7257            .expect("invalid params");
7258        let resolver = crate::config::endpoint::DefaultResolver::new();
7259        let endpoint = resolver.resolve_endpoint(&params);
7260        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support Dual-stack [WriteGetObjectResponse with dualstack]");
7261        assert_eq!(format!("{}", error), "S3 Object Lambda does not support Dual-stack")
7262    }
7263
7264    /// WriteGetObjectResponse with accelerate
7265    #[test]
7266    fn test_257() {
7267        let params = crate::config::endpoint::Params::builder()
7268            .accelerate(true)
7269            .use_object_lambda_endpoint(true)
7270            .region("us-east-1".to_string())
7271            .use_dual_stack(false)
7272            .use_fips(false)
7273            .build()
7274            .expect("invalid params");
7275        let resolver = crate::config::endpoint::DefaultResolver::new();
7276        let endpoint = resolver.resolve_endpoint(&params);
7277        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support S3 Accelerate [WriteGetObjectResponse with accelerate]");
7278        assert_eq!(format!("{}", error), "S3 Object Lambda does not support S3 Accelerate")
7279    }
7280
7281    /// WriteGetObjectResponse with fips in CN
7282    #[test]
7283    fn test_258() {
7284        let params = crate::config::endpoint::Params::builder()
7285            .accelerate(false)
7286            .region("cn-north-1".to_string())
7287            .use_object_lambda_endpoint(true)
7288            .use_dual_stack(false)
7289            .use_fips(true)
7290            .build()
7291            .expect("invalid params");
7292        let resolver = crate::config::endpoint::DefaultResolver::new();
7293        let endpoint = resolver.resolve_endpoint(&params);
7294        let error = endpoint.expect_err("expected error: Partition does not support FIPS [WriteGetObjectResponse with fips in CN]");
7295        assert_eq!(format!("{}", error), "Partition does not support FIPS")
7296    }
7297
7298    /// WriteGetObjectResponse with invalid partition
7299    #[test]
7300    fn test_259() {
7301        let params = crate::config::endpoint::Params::builder()
7302            .accelerate(false)
7303            .use_object_lambda_endpoint(true)
7304            .region("not a valid DNS name".to_string())
7305            .use_dual_stack(false)
7306            .use_fips(false)
7307            .build()
7308            .expect("invalid params");
7309        let resolver = crate::config::endpoint::DefaultResolver::new();
7310        let endpoint = resolver.resolve_endpoint(&params);
7311        let error =
7312            endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [WriteGetObjectResponse with invalid partition]");
7313        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
7314    }
7315
7316    /// WriteGetObjectResponse with an unknown partition
7317    #[test]
7318    fn test_260() {
7319        let params = crate::config::endpoint::Params::builder()
7320            .accelerate(false)
7321            .use_object_lambda_endpoint(true)
7322            .region("us-east.special".to_string())
7323            .use_dual_stack(false)
7324            .use_fips(false)
7325            .build()
7326            .expect("invalid params");
7327        let resolver = crate::config::endpoint::DefaultResolver::new();
7328        let endpoint = resolver.resolve_endpoint(&params);
7329        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-east.special.amazonaws.com");
7330        assert_eq!(
7331            endpoint,
7332            ::aws_smithy_types::endpoint::Endpoint::builder()
7333                .url("https://s3-object-lambda.us-east.special.amazonaws.com")
7334                .property(
7335                    "authSchemes",
7336                    vec![{
7337                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7338                        out.insert("name".to_string(), "sigv4".to_string().into());
7339                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7340                        out.insert("disableDoubleEncoding".to_string(), true.into());
7341                        out.insert("signingRegion".to_string(), "us-east.special".to_string().into());
7342                        out
7343                    }
7344                    .into()]
7345                )
7346                .build()
7347        );
7348    }
7349
7350    /// S3 Outposts bucketAlias Real Outpost Prod us-west-1
7351    #[test]
7352    fn test_261() {
7353        let params = crate::config::endpoint::Params::builder()
7354            .region("us-west-1".to_string())
7355            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7356            .use_fips(false)
7357            .use_dual_stack(false)
7358            .accelerate(false)
7359            .build()
7360            .expect("invalid params");
7361        let resolver = crate::config::endpoint::DefaultResolver::new();
7362        let endpoint = resolver.resolve_endpoint(&params);
7363        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.us-west-1.amazonaws.com");
7364        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")
7365    .property("authSchemes", vec![ {
7366        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7367        out.insert("name".to_string(), "sigv4a".to_string().into());
7368        out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7369        out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
7370        out.insert("disableDoubleEncoding".to_string(), true.into());
7371        out
7372    }.into()
7373    , {
7374        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7375        out.insert("name".to_string(), "sigv4".to_string().into());
7376        out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7377        out.insert("signingRegion".to_string(), "us-west-1".to_string().into());
7378        out.insert("disableDoubleEncoding".to_string(), true.into());
7379        out
7380    }.into()])
7381    .build());
7382    }
7383
7384    /// S3 Outposts bucketAlias Real Outpost Prod ap-east-1
7385    #[test]
7386    fn test_262() {
7387        let params = crate::config::endpoint::Params::builder()
7388            .region("ap-east-1".to_string())
7389            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7390            .use_fips(false)
7391            .use_dual_stack(false)
7392            .accelerate(false)
7393            .build()
7394            .expect("invalid params");
7395        let resolver = crate::config::endpoint::DefaultResolver::new();
7396        let endpoint = resolver.resolve_endpoint(&params);
7397        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.ap-east-1.amazonaws.com");
7398        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")
7399    .property("authSchemes", vec![ {
7400        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7401        out.insert("name".to_string(), "sigv4a".to_string().into());
7402        out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7403        out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
7404        out.insert("disableDoubleEncoding".to_string(), true.into());
7405        out
7406    }.into()
7407    , {
7408        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7409        out.insert("name".to_string(), "sigv4".to_string().into());
7410        out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7411        out.insert("signingRegion".to_string(), "ap-east-1".to_string().into());
7412        out.insert("disableDoubleEncoding".to_string(), true.into());
7413        out
7414    }.into()])
7415    .build());
7416    }
7417
7418    /// S3 Outposts bucketAlias Ec2 Outpost Prod us-east-1
7419    #[test]
7420    fn test_263() {
7421        let params = crate::config::endpoint::Params::builder()
7422            .region("us-east-1".to_string())
7423            .bucket("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7424            .use_fips(false)
7425            .use_dual_stack(false)
7426            .accelerate(false)
7427            .build()
7428            .expect("invalid params");
7429        let resolver = crate::config::endpoint::DefaultResolver::new();
7430        let endpoint = resolver.resolve_endpoint(&params);
7431        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.us-east-1.amazonaws.com");
7432        assert_eq!(
7433            endpoint,
7434            ::aws_smithy_types::endpoint::Endpoint::builder()
7435                .url("https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.us-east-1.amazonaws.com")
7436                .property(
7437                    "authSchemes",
7438                    vec![
7439                        {
7440                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7441                            out.insert("name".to_string(), "sigv4a".to_string().into());
7442                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7443                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
7444                            out.insert("disableDoubleEncoding".to_string(), true.into());
7445                            out
7446                        }
7447                        .into(),
7448                        {
7449                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7450                            out.insert("name".to_string(), "sigv4".to_string().into());
7451                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7452                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7453                            out.insert("disableDoubleEncoding".to_string(), true.into());
7454                            out
7455                        }
7456                        .into()
7457                    ]
7458                )
7459                .build()
7460        );
7461    }
7462
7463    /// S3 Outposts bucketAlias Ec2 Outpost Prod me-south-1
7464    #[test]
7465    fn test_264() {
7466        let params = crate::config::endpoint::Params::builder()
7467            .region("me-south-1".to_string())
7468            .bucket("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7469            .use_fips(false)
7470            .use_dual_stack(false)
7471            .accelerate(false)
7472            .build()
7473            .expect("invalid params");
7474        let resolver = crate::config::endpoint::DefaultResolver::new();
7475        let endpoint = resolver.resolve_endpoint(&params);
7476        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.me-south-1.amazonaws.com");
7477        assert_eq!(
7478            endpoint,
7479            ::aws_smithy_types::endpoint::Endpoint::builder()
7480                .url("https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.me-south-1.amazonaws.com")
7481                .property(
7482                    "authSchemes",
7483                    vec![
7484                        {
7485                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7486                            out.insert("name".to_string(), "sigv4a".to_string().into());
7487                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7488                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
7489                            out.insert("disableDoubleEncoding".to_string(), true.into());
7490                            out
7491                        }
7492                        .into(),
7493                        {
7494                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7495                            out.insert("name".to_string(), "sigv4".to_string().into());
7496                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7497                            out.insert("signingRegion".to_string(), "me-south-1".to_string().into());
7498                            out.insert("disableDoubleEncoding".to_string(), true.into());
7499                            out
7500                        }
7501                        .into()
7502                    ]
7503                )
7504                .build()
7505        );
7506    }
7507
7508    /// S3 Outposts bucketAlias Real Outpost Beta
7509    #[test]
7510    fn test_265() {
7511        let params = crate::config::endpoint::Params::builder()
7512            .region("us-east-1".to_string())
7513            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
7514            .endpoint("https://example.amazonaws.com".to_string())
7515            .use_fips(false)
7516            .use_dual_stack(false)
7517            .accelerate(false)
7518            .build()
7519            .expect("invalid params");
7520        let resolver = crate::config::endpoint::DefaultResolver::new();
7521        let endpoint = resolver.resolve_endpoint(&params);
7522        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3.op-0b1d075431d83bebd.example.amazonaws.com");
7523        assert_eq!(
7524            endpoint,
7525            ::aws_smithy_types::endpoint::Endpoint::builder()
7526                .url("https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3.op-0b1d075431d83bebd.example.amazonaws.com")
7527                .property(
7528                    "authSchemes",
7529                    vec![
7530                        {
7531                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7532                            out.insert("name".to_string(), "sigv4a".to_string().into());
7533                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7534                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
7535                            out.insert("disableDoubleEncoding".to_string(), true.into());
7536                            out
7537                        }
7538                        .into(),
7539                        {
7540                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7541                            out.insert("name".to_string(), "sigv4".to_string().into());
7542                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7543                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7544                            out.insert("disableDoubleEncoding".to_string(), true.into());
7545                            out
7546                        }
7547                        .into()
7548                    ]
7549                )
7550                .build()
7551        );
7552    }
7553
7554    /// S3 Outposts bucketAlias Ec2 Outpost Beta
7555    #[test]
7556    fn test_266() {
7557        let params = crate::config::endpoint::Params::builder()
7558            .region("us-east-1".to_string())
7559            .bucket("161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3".to_string())
7560            .endpoint("https://example.amazonaws.com".to_string())
7561            .use_fips(false)
7562            .use_dual_stack(false)
7563            .accelerate(false)
7564            .build()
7565            .expect("invalid params");
7566        let resolver = crate::config::endpoint::DefaultResolver::new();
7567        let endpoint = resolver.resolve_endpoint(&params);
7568        let endpoint = endpoint
7569            .expect("Expected valid endpoint: https://161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3.ec2.example.amazonaws.com");
7570        assert_eq!(
7571            endpoint,
7572            ::aws_smithy_types::endpoint::Endpoint::builder()
7573                .url("https://161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3.ec2.example.amazonaws.com")
7574                .property(
7575                    "authSchemes",
7576                    vec![
7577                        {
7578                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7579                            out.insert("name".to_string(), "sigv4a".to_string().into());
7580                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7581                            out.insert("signingRegionSet".to_string(), vec!["*".to_string().into()].into());
7582                            out.insert("disableDoubleEncoding".to_string(), true.into());
7583                            out
7584                        }
7585                        .into(),
7586                        {
7587                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7588                            out.insert("name".to_string(), "sigv4".to_string().into());
7589                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7590                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7591                            out.insert("disableDoubleEncoding".to_string(), true.into());
7592                            out
7593                        }
7594                        .into()
7595                    ]
7596                )
7597                .build()
7598        );
7599    }
7600
7601    /// S3 Outposts bucketAlias - No endpoint set for beta
7602    #[test]
7603    fn test_267() {
7604        let params = crate::config::endpoint::Params::builder()
7605            .region("us-east-1".to_string())
7606            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
7607            .use_fips(false)
7608            .use_dual_stack(false)
7609            .accelerate(false)
7610            .build()
7611            .expect("invalid params");
7612        let resolver = crate::config::endpoint::DefaultResolver::new();
7613        let endpoint = resolver.resolve_endpoint(&params);
7614        let error = endpoint.expect_err(
7615            "expected error: Expected a endpoint to be specified but no endpoint was found [S3 Outposts bucketAlias - No endpoint set for beta]",
7616        );
7617        assert_eq!(format!("{}", error), "Expected a endpoint to be specified but no endpoint was found")
7618    }
7619
7620    /// S3 Outposts bucketAlias Invalid hardware type
7621    #[test]
7622    fn test_268() {
7623        let params = crate::config::endpoint::Params::builder()
7624            .region("us-east-1".to_string())
7625            .bucket("test-accessp-h0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7626            .use_fips(false)
7627            .use_dual_stack(false)
7628            .accelerate(false)
7629            .build()
7630            .expect("invalid params");
7631        let resolver = crate::config::endpoint::DefaultResolver::new();
7632        let endpoint = resolver.resolve_endpoint(&params);
7633        let error = endpoint.expect_err(
7634            "expected error: Unrecognized hardware type: \"Expected hardware type o or e but got h\" [S3 Outposts bucketAlias Invalid hardware type]",
7635        );
7636        assert_eq!(
7637            format!("{}", error),
7638            "Unrecognized hardware type: \"Expected hardware type o or e but got h\""
7639        )
7640    }
7641
7642    /// S3 Outposts bucketAlias Special character in Outpost Arn
7643    #[test]
7644    fn test_269() {
7645        let params = crate::config::endpoint::Params::builder()
7646            .region("us-east-1".to_string())
7647            .bucket("test-accessp-o00000754%1d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7648            .use_fips(false)
7649            .use_dual_stack(false)
7650            .accelerate(false)
7651            .build()
7652            .expect("invalid params");
7653        let resolver = crate::config::endpoint::DefaultResolver::new();
7654        let endpoint = resolver.resolve_endpoint(&params);
7655        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]");
7656        assert_eq!(
7657            format!("{}", error),
7658            "Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`."
7659        )
7660    }
7661
7662    /// S3 Outposts bucketAlias - No endpoint set for beta
7663    #[test]
7664    fn test_270() {
7665        let params = crate::config::endpoint::Params::builder()
7666            .region("us-east-1".to_string())
7667            .bucket("test-accessp-e0b1d075431d83bebde8xz5w8ijx1qzlbp3i3ebeta0--op-s3".to_string())
7668            .use_fips(false)
7669            .use_dual_stack(false)
7670            .accelerate(false)
7671            .build()
7672            .expect("invalid params");
7673        let resolver = crate::config::endpoint::DefaultResolver::new();
7674        let endpoint = resolver.resolve_endpoint(&params);
7675        let error = endpoint.expect_err(
7676            "expected error: Expected a endpoint to be specified but no endpoint was found [S3 Outposts bucketAlias - No endpoint set for beta]",
7677        );
7678        assert_eq!(format!("{}", error), "Expected a endpoint to be specified but no endpoint was found")
7679    }
7680
7681    /// S3 Snow with bucket
7682    #[test]
7683    fn test_271() {
7684        let params = crate::config::endpoint::Params::builder()
7685            .region("snow".to_string())
7686            .bucket("bucketName".to_string())
7687            .endpoint("http://10.0.1.12:433".to_string())
7688            .use_fips(false)
7689            .use_dual_stack(false)
7690            .accelerate(false)
7691            .build()
7692            .expect("invalid params");
7693        let resolver = crate::config::endpoint::DefaultResolver::new();
7694        let endpoint = resolver.resolve_endpoint(&params);
7695        let endpoint = endpoint.expect("Expected valid endpoint: http://10.0.1.12:433/bucketName");
7696        assert_eq!(
7697            endpoint,
7698            ::aws_smithy_types::endpoint::Endpoint::builder()
7699                .url("http://10.0.1.12:433/bucketName")
7700                .property(
7701                    "authSchemes",
7702                    vec![{
7703                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7704                        out.insert("name".to_string(), "sigv4".to_string().into());
7705                        out.insert("signingName".to_string(), "s3".to_string().into());
7706                        out.insert("signingRegion".to_string(), "snow".to_string().into());
7707                        out.insert("disableDoubleEncoding".to_string(), true.into());
7708                        out
7709                    }
7710                    .into()]
7711                )
7712                .build()
7713        );
7714    }
7715
7716    /// S3 Snow without bucket
7717    #[test]
7718    fn test_272() {
7719        let params = crate::config::endpoint::Params::builder()
7720            .region("snow".to_string())
7721            .endpoint("https://10.0.1.12:433".to_string())
7722            .use_fips(false)
7723            .use_dual_stack(false)
7724            .accelerate(false)
7725            .build()
7726            .expect("invalid params");
7727        let resolver = crate::config::endpoint::DefaultResolver::new();
7728        let endpoint = resolver.resolve_endpoint(&params);
7729        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.1.12:433");
7730        assert_eq!(
7731            endpoint,
7732            ::aws_smithy_types::endpoint::Endpoint::builder()
7733                .url("https://10.0.1.12:433")
7734                .property(
7735                    "authSchemes",
7736                    vec![{
7737                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7738                        out.insert("name".to_string(), "sigv4".to_string().into());
7739                        out.insert("signingName".to_string(), "s3".to_string().into());
7740                        out.insert("signingRegion".to_string(), "snow".to_string().into());
7741                        out.insert("disableDoubleEncoding".to_string(), true.into());
7742                        out
7743                    }
7744                    .into()]
7745                )
7746                .build()
7747        );
7748    }
7749
7750    /// S3 Snow no port
7751    #[test]
7752    fn test_273() {
7753        let params = crate::config::endpoint::Params::builder()
7754            .region("snow".to_string())
7755            .bucket("bucketName".to_string())
7756            .endpoint("http://10.0.1.12".to_string())
7757            .use_fips(false)
7758            .use_dual_stack(false)
7759            .accelerate(false)
7760            .build()
7761            .expect("invalid params");
7762        let resolver = crate::config::endpoint::DefaultResolver::new();
7763        let endpoint = resolver.resolve_endpoint(&params);
7764        let endpoint = endpoint.expect("Expected valid endpoint: http://10.0.1.12/bucketName");
7765        assert_eq!(
7766            endpoint,
7767            ::aws_smithy_types::endpoint::Endpoint::builder()
7768                .url("http://10.0.1.12/bucketName")
7769                .property(
7770                    "authSchemes",
7771                    vec![{
7772                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7773                        out.insert("name".to_string(), "sigv4".to_string().into());
7774                        out.insert("signingName".to_string(), "s3".to_string().into());
7775                        out.insert("signingRegion".to_string(), "snow".to_string().into());
7776                        out.insert("disableDoubleEncoding".to_string(), true.into());
7777                        out
7778                    }
7779                    .into()]
7780                )
7781                .build()
7782        );
7783    }
7784
7785    /// S3 Snow dns endpoint
7786    #[test]
7787    fn test_274() {
7788        let params = crate::config::endpoint::Params::builder()
7789            .region("snow".to_string())
7790            .bucket("bucketName".to_string())
7791            .endpoint("https://amazonaws.com".to_string())
7792            .use_fips(false)
7793            .use_dual_stack(false)
7794            .accelerate(false)
7795            .build()
7796            .expect("invalid params");
7797        let resolver = crate::config::endpoint::DefaultResolver::new();
7798        let endpoint = resolver.resolve_endpoint(&params);
7799        let endpoint = endpoint.expect("Expected valid endpoint: https://amazonaws.com/bucketName");
7800        assert_eq!(
7801            endpoint,
7802            ::aws_smithy_types::endpoint::Endpoint::builder()
7803                .url("https://amazonaws.com/bucketName")
7804                .property(
7805                    "authSchemes",
7806                    vec![{
7807                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7808                        out.insert("name".to_string(), "sigv4".to_string().into());
7809                        out.insert("signingName".to_string(), "s3".to_string().into());
7810                        out.insert("signingRegion".to_string(), "snow".to_string().into());
7811                        out.insert("disableDoubleEncoding".to_string(), true.into());
7812                        out
7813                    }
7814                    .into()]
7815                )
7816                .build()
7817        );
7818    }
7819
7820    /// Data Plane with short zone name
7821    #[test]
7822    fn test_275() {
7823        let params = crate::config::endpoint::Params::builder()
7824            .region("us-east-1".to_string())
7825            .bucket("mybucket--abcd-ab1--x-s3".to_string())
7826            .use_fips(false)
7827            .use_dual_stack(false)
7828            .accelerate(false)
7829            .use_s3_express_control_endpoint(false)
7830            .build()
7831            .expect("invalid params");
7832        let resolver = crate::config::endpoint::DefaultResolver::new();
7833        let endpoint = resolver.resolve_endpoint(&params);
7834        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com");
7835        assert_eq!(
7836            endpoint,
7837            ::aws_smithy_types::endpoint::Endpoint::builder()
7838                .url("https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com")
7839                .property(
7840                    "authSchemes",
7841                    vec![{
7842                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7843                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7844                        out.insert("signingName".to_string(), "s3express".to_string().into());
7845                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7846                        out.insert("disableDoubleEncoding".to_string(), true.into());
7847                        out
7848                    }
7849                    .into()]
7850                )
7851                .property("backend", "S3Express".to_string())
7852                .build()
7853        );
7854    }
7855
7856    /// Data Plane with short zone names (13 chars)
7857    #[test]
7858    fn test_276() {
7859        let params = crate::config::endpoint::Params::builder()
7860            .region("us-west-2".to_string())
7861            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
7862            .use_fips(false)
7863            .use_dual_stack(false)
7864            .accelerate(false)
7865            .use_s3_express_control_endpoint(false)
7866            .build()
7867            .expect("invalid params");
7868        let resolver = crate::config::endpoint::DefaultResolver::new();
7869        let endpoint = resolver.resolve_endpoint(&params);
7870        let endpoint =
7871            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
7872        assert_eq!(
7873            endpoint,
7874            ::aws_smithy_types::endpoint::Endpoint::builder()
7875                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
7876                .property(
7877                    "authSchemes",
7878                    vec![{
7879                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7880                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7881                        out.insert("signingName".to_string(), "s3express".to_string().into());
7882                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7883                        out.insert("disableDoubleEncoding".to_string(), true.into());
7884                        out
7885                    }
7886                    .into()]
7887                )
7888                .property("backend", "S3Express".to_string())
7889                .build()
7890        );
7891    }
7892
7893    /// Data Plane with medium zone names (14 chars)
7894    #[test]
7895    fn test_277() {
7896        let params = crate::config::endpoint::Params::builder()
7897            .region("us-west-2".to_string())
7898            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
7899            .use_fips(false)
7900            .use_dual_stack(false)
7901            .accelerate(false)
7902            .use_s3_express_control_endpoint(false)
7903            .build()
7904            .expect("invalid params");
7905        let resolver = crate::config::endpoint::DefaultResolver::new();
7906        let endpoint = resolver.resolve_endpoint(&params);
7907        let endpoint =
7908            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
7909        assert_eq!(
7910            endpoint,
7911            ::aws_smithy_types::endpoint::Endpoint::builder()
7912                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
7913                .property(
7914                    "authSchemes",
7915                    vec![{
7916                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7917                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7918                        out.insert("signingName".to_string(), "s3express".to_string().into());
7919                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7920                        out.insert("disableDoubleEncoding".to_string(), true.into());
7921                        out
7922                    }
7923                    .into()]
7924                )
7925                .property("backend", "S3Express".to_string())
7926                .build()
7927        );
7928    }
7929
7930    /// Data Plane with long zone names (20 chars)
7931    #[test]
7932    fn test_278() {
7933        let params = crate::config::endpoint::Params::builder()
7934            .region("us-west-2".to_string())
7935            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
7936            .use_fips(false)
7937            .use_dual_stack(false)
7938            .accelerate(false)
7939            .use_s3_express_control_endpoint(false)
7940            .build()
7941            .expect("invalid params");
7942        let resolver = crate::config::endpoint::DefaultResolver::new();
7943        let endpoint = resolver.resolve_endpoint(&params);
7944        let endpoint = endpoint
7945            .expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com");
7946        assert_eq!(
7947            endpoint,
7948            ::aws_smithy_types::endpoint::Endpoint::builder()
7949                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
7950                .property(
7951                    "authSchemes",
7952                    vec![{
7953                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7954                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7955                        out.insert("signingName".to_string(), "s3express".to_string().into());
7956                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7957                        out.insert("disableDoubleEncoding".to_string(), true.into());
7958                        out
7959                    }
7960                    .into()]
7961                )
7962                .property("backend", "S3Express".to_string())
7963                .build()
7964        );
7965    }
7966
7967    /// Data Plane with short zone fips
7968    #[test]
7969    fn test_279() {
7970        let params = crate::config::endpoint::Params::builder()
7971            .region("us-east-1".to_string())
7972            .bucket("mybucket--test-ab1--x-s3".to_string())
7973            .use_fips(true)
7974            .use_dual_stack(false)
7975            .accelerate(false)
7976            .use_s3_express_control_endpoint(false)
7977            .build()
7978            .expect("invalid params");
7979        let resolver = crate::config::endpoint::DefaultResolver::new();
7980        let endpoint = resolver.resolve_endpoint(&params);
7981        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test-ab1--x-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com");
7982        assert_eq!(
7983            endpoint,
7984            ::aws_smithy_types::endpoint::Endpoint::builder()
7985                .url("https://mybucket--test-ab1--x-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com")
7986                .property(
7987                    "authSchemes",
7988                    vec![{
7989                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7990                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7991                        out.insert("signingName".to_string(), "s3express".to_string().into());
7992                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7993                        out.insert("disableDoubleEncoding".to_string(), true.into());
7994                        out
7995                    }
7996                    .into()]
7997                )
7998                .property("backend", "S3Express".to_string())
7999                .build()
8000        );
8001    }
8002
8003    /// Data Plane with short zone (13 chars) fips
8004    #[test]
8005    fn test_280() {
8006        let params = crate::config::endpoint::Params::builder()
8007            .region("us-west-2".to_string())
8008            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
8009            .use_fips(true)
8010            .use_dual_stack(false)
8011            .accelerate(false)
8012            .use_s3_express_control_endpoint(false)
8013            .build()
8014            .expect("invalid params");
8015        let resolver = crate::config::endpoint::DefaultResolver::new();
8016        let endpoint = resolver.resolve_endpoint(&params);
8017        let endpoint =
8018            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
8019        assert_eq!(
8020            endpoint,
8021            ::aws_smithy_types::endpoint::Endpoint::builder()
8022                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
8023                .property(
8024                    "authSchemes",
8025                    vec![{
8026                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8027                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8028                        out.insert("signingName".to_string(), "s3express".to_string().into());
8029                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8030                        out.insert("disableDoubleEncoding".to_string(), true.into());
8031                        out
8032                    }
8033                    .into()]
8034                )
8035                .property("backend", "S3Express".to_string())
8036                .build()
8037        );
8038    }
8039
8040    /// Data Plane with medium zone (14 chars) fips
8041    #[test]
8042    fn test_281() {
8043        let params = crate::config::endpoint::Params::builder()
8044            .region("us-west-2".to_string())
8045            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
8046            .use_fips(true)
8047            .use_dual_stack(false)
8048            .accelerate(false)
8049            .use_s3_express_control_endpoint(false)
8050            .build()
8051            .expect("invalid params");
8052        let resolver = crate::config::endpoint::DefaultResolver::new();
8053        let endpoint = resolver.resolve_endpoint(&params);
8054        let endpoint =
8055            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
8056        assert_eq!(
8057            endpoint,
8058            ::aws_smithy_types::endpoint::Endpoint::builder()
8059                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
8060                .property(
8061                    "authSchemes",
8062                    vec![{
8063                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8064                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8065                        out.insert("signingName".to_string(), "s3express".to_string().into());
8066                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8067                        out.insert("disableDoubleEncoding".to_string(), true.into());
8068                        out
8069                    }
8070                    .into()]
8071                )
8072                .property("backend", "S3Express".to_string())
8073                .build()
8074        );
8075    }
8076
8077    /// Data Plane with long zone (20 chars) fips
8078    #[test]
8079    fn test_282() {
8080        let params = crate::config::endpoint::Params::builder()
8081            .region("us-west-2".to_string())
8082            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
8083            .use_fips(true)
8084            .use_dual_stack(false)
8085            .accelerate(false)
8086            .use_s3_express_control_endpoint(false)
8087            .build()
8088            .expect("invalid params");
8089        let resolver = crate::config::endpoint::DefaultResolver::new();
8090        let endpoint = resolver.resolve_endpoint(&params);
8091        let endpoint = endpoint.expect(
8092            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
8093        );
8094        assert_eq!(
8095            endpoint,
8096            ::aws_smithy_types::endpoint::Endpoint::builder()
8097                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
8098                .property(
8099                    "authSchemes",
8100                    vec![{
8101                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8102                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8103                        out.insert("signingName".to_string(), "s3express".to_string().into());
8104                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8105                        out.insert("disableDoubleEncoding".to_string(), true.into());
8106                        out
8107                    }
8108                    .into()]
8109                )
8110                .property("backend", "S3Express".to_string())
8111                .build()
8112        );
8113    }
8114
8115    /// Data Plane with long AZ
8116    #[test]
8117    fn test_283() {
8118        let params = crate::config::endpoint::Params::builder()
8119            .region("us-west-2".to_string())
8120            .bucket("mybucket--test1-az1--x-s3".to_string())
8121            .use_fips(false)
8122            .use_dual_stack(false)
8123            .accelerate(false)
8124            .use_s3_express_control_endpoint(false)
8125            .build()
8126            .expect("invalid params");
8127        let resolver = crate::config::endpoint::DefaultResolver::new();
8128        let endpoint = resolver.resolve_endpoint(&params);
8129        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com");
8130        assert_eq!(
8131            endpoint,
8132            ::aws_smithy_types::endpoint::Endpoint::builder()
8133                .url("https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com")
8134                .property(
8135                    "authSchemes",
8136                    vec![{
8137                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8138                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8139                        out.insert("signingName".to_string(), "s3express".to_string().into());
8140                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8141                        out.insert("disableDoubleEncoding".to_string(), true.into());
8142                        out
8143                    }
8144                    .into()]
8145                )
8146                .property("backend", "S3Express".to_string())
8147                .build()
8148        );
8149    }
8150
8151    /// Data Plane with long AZ fips
8152    #[test]
8153    fn test_284() {
8154        let params = crate::config::endpoint::Params::builder()
8155            .region("us-west-2".to_string())
8156            .bucket("mybucket--test1-az1--x-s3".to_string())
8157            .use_fips(true)
8158            .use_dual_stack(false)
8159            .accelerate(false)
8160            .use_s3_express_control_endpoint(false)
8161            .build()
8162            .expect("invalid params");
8163        let resolver = crate::config::endpoint::DefaultResolver::new();
8164        let endpoint = resolver.resolve_endpoint(&params);
8165        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
8166        assert_eq!(
8167            endpoint,
8168            ::aws_smithy_types::endpoint::Endpoint::builder()
8169                .url("https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
8170                .property(
8171                    "authSchemes",
8172                    vec![{
8173                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8174                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8175                        out.insert("signingName".to_string(), "s3express".to_string().into());
8176                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8177                        out.insert("disableDoubleEncoding".to_string(), true.into());
8178                        out
8179                    }
8180                    .into()]
8181                )
8182                .property("backend", "S3Express".to_string())
8183                .build()
8184        );
8185    }
8186
8187    /// Control plane with short AZ bucket
8188    #[test]
8189    fn test_285() {
8190        let params = crate::config::endpoint::Params::builder()
8191            .region("us-east-1".to_string())
8192            .bucket("mybucket--test-ab1--x-s3".to_string())
8193            .use_fips(false)
8194            .use_dual_stack(false)
8195            .accelerate(false)
8196            .use_s3_express_control_endpoint(true)
8197            .disable_s3_express_session_auth(false)
8198            .build()
8199            .expect("invalid params");
8200        let resolver = crate::config::endpoint::DefaultResolver::new();
8201        let endpoint = resolver.resolve_endpoint(&params);
8202        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
8203        assert_eq!(
8204            endpoint,
8205            ::aws_smithy_types::endpoint::Endpoint::builder()
8206                .url("https://s3express-control.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
8207                .property(
8208                    "authSchemes",
8209                    vec![{
8210                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8211                        out.insert("name".to_string(), "sigv4".to_string().into());
8212                        out.insert("signingName".to_string(), "s3express".to_string().into());
8213                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
8214                        out.insert("disableDoubleEncoding".to_string(), true.into());
8215                        out
8216                    }
8217                    .into()]
8218                )
8219                .property("backend", "S3Express".to_string())
8220                .build()
8221        );
8222    }
8223
8224    /// Control plane with short AZ bucket and fips
8225    #[test]
8226    fn test_286() {
8227        let params = crate::config::endpoint::Params::builder()
8228            .region("us-east-1".to_string())
8229            .bucket("mybucket--test-ab1--x-s3".to_string())
8230            .use_fips(true)
8231            .use_dual_stack(false)
8232            .accelerate(false)
8233            .use_s3_express_control_endpoint(true)
8234            .disable_s3_express_session_auth(false)
8235            .build()
8236            .expect("invalid params");
8237        let resolver = crate::config::endpoint::DefaultResolver::new();
8238        let endpoint = resolver.resolve_endpoint(&params);
8239        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
8240        assert_eq!(
8241            endpoint,
8242            ::aws_smithy_types::endpoint::Endpoint::builder()
8243                .url("https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
8244                .property(
8245                    "authSchemes",
8246                    vec![{
8247                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8248                        out.insert("name".to_string(), "sigv4".to_string().into());
8249                        out.insert("signingName".to_string(), "s3express".to_string().into());
8250                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
8251                        out.insert("disableDoubleEncoding".to_string(), true.into());
8252                        out
8253                    }
8254                    .into()]
8255                )
8256                .property("backend", "S3Express".to_string())
8257                .build()
8258        );
8259    }
8260
8261    /// Control plane without bucket
8262    #[test]
8263    fn test_287() {
8264        let params = crate::config::endpoint::Params::builder()
8265            .region("us-east-1".to_string())
8266            .use_fips(false)
8267            .use_dual_stack(false)
8268            .accelerate(false)
8269            .use_s3_express_control_endpoint(true)
8270            .disable_s3_express_session_auth(false)
8271            .build()
8272            .expect("invalid params");
8273        let resolver = crate::config::endpoint::DefaultResolver::new();
8274        let endpoint = resolver.resolve_endpoint(&params);
8275        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com");
8276        assert_eq!(
8277            endpoint,
8278            ::aws_smithy_types::endpoint::Endpoint::builder()
8279                .url("https://s3express-control.us-east-1.amazonaws.com")
8280                .property(
8281                    "authSchemes",
8282                    vec![{
8283                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8284                        out.insert("name".to_string(), "sigv4".to_string().into());
8285                        out.insert("signingName".to_string(), "s3express".to_string().into());
8286                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
8287                        out.insert("disableDoubleEncoding".to_string(), true.into());
8288                        out
8289                    }
8290                    .into()]
8291                )
8292                .property("backend", "S3Express".to_string())
8293                .build()
8294        );
8295    }
8296
8297    /// Control plane without bucket and fips
8298    #[test]
8299    fn test_288() {
8300        let params = crate::config::endpoint::Params::builder()
8301            .region("us-east-1".to_string())
8302            .use_fips(true)
8303            .use_dual_stack(false)
8304            .accelerate(false)
8305            .use_s3_express_control_endpoint(true)
8306            .disable_s3_express_session_auth(false)
8307            .build()
8308            .expect("invalid params");
8309        let resolver = crate::config::endpoint::DefaultResolver::new();
8310        let endpoint = resolver.resolve_endpoint(&params);
8311        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com");
8312        assert_eq!(
8313            endpoint,
8314            ::aws_smithy_types::endpoint::Endpoint::builder()
8315                .url("https://s3express-control-fips.us-east-1.amazonaws.com")
8316                .property(
8317                    "authSchemes",
8318                    vec![{
8319                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8320                        out.insert("name".to_string(), "sigv4".to_string().into());
8321                        out.insert("signingName".to_string(), "s3express".to_string().into());
8322                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
8323                        out.insert("disableDoubleEncoding".to_string(), true.into());
8324                        out
8325                    }
8326                    .into()]
8327                )
8328                .property("backend", "S3Express".to_string())
8329                .build()
8330        );
8331    }
8332
8333    /// Data Plane sigv4 auth with short AZ
8334    #[test]
8335    fn test_289() {
8336        let params = crate::config::endpoint::Params::builder()
8337            .region("us-west-2".to_string())
8338            .bucket("mybucket--usw2-az1--x-s3".to_string())
8339            .use_fips(false)
8340            .use_dual_stack(false)
8341            .accelerate(false)
8342            .disable_s3_express_session_auth(true)
8343            .build()
8344            .expect("invalid params");
8345        let resolver = crate::config::endpoint::DefaultResolver::new();
8346        let endpoint = resolver.resolve_endpoint(&params);
8347        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com");
8348        assert_eq!(
8349            endpoint,
8350            ::aws_smithy_types::endpoint::Endpoint::builder()
8351                .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com")
8352                .property(
8353                    "authSchemes",
8354                    vec![{
8355                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8356                        out.insert("name".to_string(), "sigv4".to_string().into());
8357                        out.insert("signingName".to_string(), "s3express".to_string().into());
8358                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8359                        out.insert("disableDoubleEncoding".to_string(), true.into());
8360                        out
8361                    }
8362                    .into()]
8363                )
8364                .property("backend", "S3Express".to_string())
8365                .build()
8366        );
8367    }
8368
8369    /// Data Plane sigv4 auth with short zone (13 chars)
8370    #[test]
8371    fn test_290() {
8372        let params = crate::config::endpoint::Params::builder()
8373            .region("us-west-2".to_string())
8374            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
8375            .use_fips(false)
8376            .use_dual_stack(false)
8377            .accelerate(false)
8378            .disable_s3_express_session_auth(true)
8379            .build()
8380            .expect("invalid params");
8381        let resolver = crate::config::endpoint::DefaultResolver::new();
8382        let endpoint = resolver.resolve_endpoint(&params);
8383        let endpoint =
8384            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
8385        assert_eq!(
8386            endpoint,
8387            ::aws_smithy_types::endpoint::Endpoint::builder()
8388                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
8389                .property(
8390                    "authSchemes",
8391                    vec![{
8392                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8393                        out.insert("name".to_string(), "sigv4".to_string().into());
8394                        out.insert("signingName".to_string(), "s3express".to_string().into());
8395                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8396                        out.insert("disableDoubleEncoding".to_string(), true.into());
8397                        out
8398                    }
8399                    .into()]
8400                )
8401                .property("backend", "S3Express".to_string())
8402                .build()
8403        );
8404    }
8405
8406    /// Data Plane sigv4 auth with short AZ fips
8407    #[test]
8408    fn test_291() {
8409        let params = crate::config::endpoint::Params::builder()
8410            .region("us-west-2".to_string())
8411            .bucket("mybucket--usw2-az1--x-s3".to_string())
8412            .use_fips(true)
8413            .use_dual_stack(false)
8414            .accelerate(false)
8415            .disable_s3_express_session_auth(true)
8416            .build()
8417            .expect("invalid params");
8418        let resolver = crate::config::endpoint::DefaultResolver::new();
8419        let endpoint = resolver.resolve_endpoint(&params);
8420        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com");
8421        assert_eq!(
8422            endpoint,
8423            ::aws_smithy_types::endpoint::Endpoint::builder()
8424                .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com")
8425                .property(
8426                    "authSchemes",
8427                    vec![{
8428                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8429                        out.insert("name".to_string(), "sigv4".to_string().into());
8430                        out.insert("signingName".to_string(), "s3express".to_string().into());
8431                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8432                        out.insert("disableDoubleEncoding".to_string(), true.into());
8433                        out
8434                    }
8435                    .into()]
8436                )
8437                .property("backend", "S3Express".to_string())
8438                .build()
8439        );
8440    }
8441
8442    /// Data Plane sigv4 auth with short zone (13 chars) fips
8443    #[test]
8444    fn test_292() {
8445        let params = crate::config::endpoint::Params::builder()
8446            .region("us-west-2".to_string())
8447            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
8448            .use_fips(true)
8449            .use_dual_stack(false)
8450            .accelerate(false)
8451            .disable_s3_express_session_auth(true)
8452            .build()
8453            .expect("invalid params");
8454        let resolver = crate::config::endpoint::DefaultResolver::new();
8455        let endpoint = resolver.resolve_endpoint(&params);
8456        let endpoint =
8457            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
8458        assert_eq!(
8459            endpoint,
8460            ::aws_smithy_types::endpoint::Endpoint::builder()
8461                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
8462                .property(
8463                    "authSchemes",
8464                    vec![{
8465                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8466                        out.insert("name".to_string(), "sigv4".to_string().into());
8467                        out.insert("signingName".to_string(), "s3express".to_string().into());
8468                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8469                        out.insert("disableDoubleEncoding".to_string(), true.into());
8470                        out
8471                    }
8472                    .into()]
8473                )
8474                .property("backend", "S3Express".to_string())
8475                .build()
8476        );
8477    }
8478
8479    /// Data Plane sigv4 auth with long AZ
8480    #[test]
8481    fn test_293() {
8482        let params = crate::config::endpoint::Params::builder()
8483            .region("us-west-2".to_string())
8484            .bucket("mybucket--test1-az1--x-s3".to_string())
8485            .use_fips(false)
8486            .use_dual_stack(false)
8487            .accelerate(false)
8488            .use_s3_express_control_endpoint(false)
8489            .disable_s3_express_session_auth(true)
8490            .build()
8491            .expect("invalid params");
8492        let resolver = crate::config::endpoint::DefaultResolver::new();
8493        let endpoint = resolver.resolve_endpoint(&params);
8494        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com");
8495        assert_eq!(
8496            endpoint,
8497            ::aws_smithy_types::endpoint::Endpoint::builder()
8498                .url("https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com")
8499                .property(
8500                    "authSchemes",
8501                    vec![{
8502                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8503                        out.insert("name".to_string(), "sigv4".to_string().into());
8504                        out.insert("signingName".to_string(), "s3express".to_string().into());
8505                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8506                        out.insert("disableDoubleEncoding".to_string(), true.into());
8507                        out
8508                    }
8509                    .into()]
8510                )
8511                .property("backend", "S3Express".to_string())
8512                .build()
8513        );
8514    }
8515
8516    /// Data Plane sigv4 auth with medium zone(14 chars)
8517    #[test]
8518    fn test_294() {
8519        let params = crate::config::endpoint::Params::builder()
8520            .region("us-west-2".to_string())
8521            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
8522            .use_fips(false)
8523            .use_dual_stack(false)
8524            .accelerate(false)
8525            .use_s3_express_control_endpoint(false)
8526            .disable_s3_express_session_auth(true)
8527            .build()
8528            .expect("invalid params");
8529        let resolver = crate::config::endpoint::DefaultResolver::new();
8530        let endpoint = resolver.resolve_endpoint(&params);
8531        let endpoint =
8532            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
8533        assert_eq!(
8534            endpoint,
8535            ::aws_smithy_types::endpoint::Endpoint::builder()
8536                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
8537                .property(
8538                    "authSchemes",
8539                    vec![{
8540                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8541                        out.insert("name".to_string(), "sigv4".to_string().into());
8542                        out.insert("signingName".to_string(), "s3express".to_string().into());
8543                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8544                        out.insert("disableDoubleEncoding".to_string(), true.into());
8545                        out
8546                    }
8547                    .into()]
8548                )
8549                .property("backend", "S3Express".to_string())
8550                .build()
8551        );
8552    }
8553
8554    /// Data Plane sigv4 auth with long zone(20 chars)
8555    #[test]
8556    fn test_295() {
8557        let params = crate::config::endpoint::Params::builder()
8558            .region("us-west-2".to_string())
8559            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
8560            .use_fips(false)
8561            .use_dual_stack(false)
8562            .accelerate(false)
8563            .use_s3_express_control_endpoint(false)
8564            .disable_s3_express_session_auth(true)
8565            .build()
8566            .expect("invalid params");
8567        let resolver = crate::config::endpoint::DefaultResolver::new();
8568        let endpoint = resolver.resolve_endpoint(&params);
8569        let endpoint = endpoint
8570            .expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com");
8571        assert_eq!(
8572            endpoint,
8573            ::aws_smithy_types::endpoint::Endpoint::builder()
8574                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
8575                .property(
8576                    "authSchemes",
8577                    vec![{
8578                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8579                        out.insert("name".to_string(), "sigv4".to_string().into());
8580                        out.insert("signingName".to_string(), "s3express".to_string().into());
8581                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8582                        out.insert("disableDoubleEncoding".to_string(), true.into());
8583                        out
8584                    }
8585                    .into()]
8586                )
8587                .property("backend", "S3Express".to_string())
8588                .build()
8589        );
8590    }
8591
8592    /// Data Plane sigv4 auth with long AZ fips
8593    #[test]
8594    fn test_296() {
8595        let params = crate::config::endpoint::Params::builder()
8596            .region("us-west-2".to_string())
8597            .bucket("mybucket--test1-az1--x-s3".to_string())
8598            .use_fips(true)
8599            .use_dual_stack(false)
8600            .accelerate(false)
8601            .use_s3_express_control_endpoint(false)
8602            .disable_s3_express_session_auth(true)
8603            .build()
8604            .expect("invalid params");
8605        let resolver = crate::config::endpoint::DefaultResolver::new();
8606        let endpoint = resolver.resolve_endpoint(&params);
8607        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
8608        assert_eq!(
8609            endpoint,
8610            ::aws_smithy_types::endpoint::Endpoint::builder()
8611                .url("https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
8612                .property(
8613                    "authSchemes",
8614                    vec![{
8615                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8616                        out.insert("name".to_string(), "sigv4".to_string().into());
8617                        out.insert("signingName".to_string(), "s3express".to_string().into());
8618                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8619                        out.insert("disableDoubleEncoding".to_string(), true.into());
8620                        out
8621                    }
8622                    .into()]
8623                )
8624                .property("backend", "S3Express".to_string())
8625                .build()
8626        );
8627    }
8628
8629    /// Data Plane sigv4 auth with medium zone (14 chars) fips
8630    #[test]
8631    fn test_297() {
8632        let params = crate::config::endpoint::Params::builder()
8633            .region("us-west-2".to_string())
8634            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
8635            .use_fips(true)
8636            .use_dual_stack(false)
8637            .accelerate(false)
8638            .use_s3_express_control_endpoint(false)
8639            .disable_s3_express_session_auth(true)
8640            .build()
8641            .expect("invalid params");
8642        let resolver = crate::config::endpoint::DefaultResolver::new();
8643        let endpoint = resolver.resolve_endpoint(&params);
8644        let endpoint =
8645            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
8646        assert_eq!(
8647            endpoint,
8648            ::aws_smithy_types::endpoint::Endpoint::builder()
8649                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
8650                .property(
8651                    "authSchemes",
8652                    vec![{
8653                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8654                        out.insert("name".to_string(), "sigv4".to_string().into());
8655                        out.insert("signingName".to_string(), "s3express".to_string().into());
8656                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8657                        out.insert("disableDoubleEncoding".to_string(), true.into());
8658                        out
8659                    }
8660                    .into()]
8661                )
8662                .property("backend", "S3Express".to_string())
8663                .build()
8664        );
8665    }
8666
8667    /// Data Plane sigv4 auth with long zone (20 chars) fips
8668    #[test]
8669    fn test_298() {
8670        let params = crate::config::endpoint::Params::builder()
8671            .region("us-west-2".to_string())
8672            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
8673            .use_fips(true)
8674            .use_dual_stack(false)
8675            .accelerate(false)
8676            .use_s3_express_control_endpoint(false)
8677            .disable_s3_express_session_auth(true)
8678            .build()
8679            .expect("invalid params");
8680        let resolver = crate::config::endpoint::DefaultResolver::new();
8681        let endpoint = resolver.resolve_endpoint(&params);
8682        let endpoint = endpoint.expect(
8683            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
8684        );
8685        assert_eq!(
8686            endpoint,
8687            ::aws_smithy_types::endpoint::Endpoint::builder()
8688                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
8689                .property(
8690                    "authSchemes",
8691                    vec![{
8692                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8693                        out.insert("name".to_string(), "sigv4".to_string().into());
8694                        out.insert("signingName".to_string(), "s3express".to_string().into());
8695                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8696                        out.insert("disableDoubleEncoding".to_string(), true.into());
8697                        out
8698                    }
8699                    .into()]
8700                )
8701                .property("backend", "S3Express".to_string())
8702                .build()
8703        );
8704    }
8705
8706    /// Control Plane host override
8707    #[test]
8708    fn test_299() {
8709        let params = crate::config::endpoint::Params::builder()
8710            .region("us-west-2".to_string())
8711            .bucket("mybucket--usw2-az1--x-s3".to_string())
8712            .use_fips(false)
8713            .use_dual_stack(false)
8714            .accelerate(false)
8715            .use_s3_express_control_endpoint(true)
8716            .disable_s3_express_session_auth(true)
8717            .endpoint("https://custom.com".to_string())
8718            .build()
8719            .expect("invalid params");
8720        let resolver = crate::config::endpoint::DefaultResolver::new();
8721        let endpoint = resolver.resolve_endpoint(&params);
8722        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
8723        assert_eq!(
8724            endpoint,
8725            ::aws_smithy_types::endpoint::Endpoint::builder()
8726                .url("https://mybucket--usw2-az1--x-s3.custom.com")
8727                .property(
8728                    "authSchemes",
8729                    vec![{
8730                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8731                        out.insert("name".to_string(), "sigv4".to_string().into());
8732                        out.insert("signingName".to_string(), "s3express".to_string().into());
8733                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8734                        out.insert("disableDoubleEncoding".to_string(), true.into());
8735                        out
8736                    }
8737                    .into()]
8738                )
8739                .property("backend", "S3Express".to_string())
8740                .build()
8741        );
8742    }
8743
8744    /// Control Plane host override no bucket
8745    #[test]
8746    fn test_300() {
8747        let params = crate::config::endpoint::Params::builder()
8748            .region("us-west-2".to_string())
8749            .use_fips(false)
8750            .use_dual_stack(false)
8751            .accelerate(false)
8752            .use_s3_express_control_endpoint(true)
8753            .disable_s3_express_session_auth(true)
8754            .endpoint("https://custom.com".to_string())
8755            .build()
8756            .expect("invalid params");
8757        let resolver = crate::config::endpoint::DefaultResolver::new();
8758        let endpoint = resolver.resolve_endpoint(&params);
8759        let endpoint = endpoint.expect("Expected valid endpoint: https://custom.com");
8760        assert_eq!(
8761            endpoint,
8762            ::aws_smithy_types::endpoint::Endpoint::builder()
8763                .url("https://custom.com")
8764                .property(
8765                    "authSchemes",
8766                    vec![{
8767                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8768                        out.insert("name".to_string(), "sigv4".to_string().into());
8769                        out.insert("signingName".to_string(), "s3express".to_string().into());
8770                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8771                        out.insert("disableDoubleEncoding".to_string(), true.into());
8772                        out
8773                    }
8774                    .into()]
8775                )
8776                .property("backend", "S3Express".to_string())
8777                .build()
8778        );
8779    }
8780
8781    /// Data plane host override non virtual session auth
8782    #[test]
8783    fn test_301() {
8784        let params = crate::config::endpoint::Params::builder()
8785            .region("us-west-2".to_string())
8786            .bucket("mybucket--usw2-az1--x-s3".to_string())
8787            .use_fips(false)
8788            .use_dual_stack(false)
8789            .accelerate(false)
8790            .endpoint("https://10.0.0.1".to_string())
8791            .build()
8792            .expect("invalid params");
8793        let resolver = crate::config::endpoint::DefaultResolver::new();
8794        let endpoint = resolver.resolve_endpoint(&params);
8795        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
8796        assert_eq!(
8797            endpoint,
8798            ::aws_smithy_types::endpoint::Endpoint::builder()
8799                .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
8800                .property(
8801                    "authSchemes",
8802                    vec![{
8803                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8804                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8805                        out.insert("signingName".to_string(), "s3express".to_string().into());
8806                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8807                        out.insert("disableDoubleEncoding".to_string(), true.into());
8808                        out
8809                    }
8810                    .into()]
8811                )
8812                .property("backend", "S3Express".to_string())
8813                .build()
8814        );
8815    }
8816
8817    /// Control Plane host override ip
8818    #[test]
8819    fn test_302() {
8820        let params = crate::config::endpoint::Params::builder()
8821            .region("us-west-2".to_string())
8822            .bucket("mybucket--usw2-az1--x-s3".to_string())
8823            .use_fips(false)
8824            .use_dual_stack(false)
8825            .accelerate(false)
8826            .use_s3_express_control_endpoint(true)
8827            .disable_s3_express_session_auth(true)
8828            .endpoint("https://10.0.0.1".to_string())
8829            .build()
8830            .expect("invalid params");
8831        let resolver = crate::config::endpoint::DefaultResolver::new();
8832        let endpoint = resolver.resolve_endpoint(&params);
8833        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
8834        assert_eq!(
8835            endpoint,
8836            ::aws_smithy_types::endpoint::Endpoint::builder()
8837                .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
8838                .property(
8839                    "authSchemes",
8840                    vec![{
8841                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8842                        out.insert("name".to_string(), "sigv4".to_string().into());
8843                        out.insert("signingName".to_string(), "s3express".to_string().into());
8844                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8845                        out.insert("disableDoubleEncoding".to_string(), true.into());
8846                        out
8847                    }
8848                    .into()]
8849                )
8850                .property("backend", "S3Express".to_string())
8851                .build()
8852        );
8853    }
8854
8855    /// Data plane host override
8856    #[test]
8857    fn test_303() {
8858        let params = crate::config::endpoint::Params::builder()
8859            .region("us-west-2".to_string())
8860            .bucket("mybucket--usw2-az1--x-s3".to_string())
8861            .use_fips(false)
8862            .use_dual_stack(false)
8863            .accelerate(false)
8864            .endpoint("https://custom.com".to_string())
8865            .build()
8866            .expect("invalid params");
8867        let resolver = crate::config::endpoint::DefaultResolver::new();
8868        let endpoint = resolver.resolve_endpoint(&params);
8869        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
8870        assert_eq!(
8871            endpoint,
8872            ::aws_smithy_types::endpoint::Endpoint::builder()
8873                .url("https://mybucket--usw2-az1--x-s3.custom.com")
8874                .property(
8875                    "authSchemes",
8876                    vec![{
8877                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8878                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8879                        out.insert("signingName".to_string(), "s3express".to_string().into());
8880                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8881                        out.insert("disableDoubleEncoding".to_string(), true.into());
8882                        out
8883                    }
8884                    .into()]
8885                )
8886                .property("backend", "S3Express".to_string())
8887                .build()
8888        );
8889    }
8890
8891    /// bad format error
8892    #[test]
8893    fn test_304() {
8894        let params = crate::config::endpoint::Params::builder()
8895            .region("us-east-1".to_string())
8896            .bucket("mybucket--usaz1--x-s3".to_string())
8897            .use_fips(false)
8898            .use_dual_stack(false)
8899            .accelerate(false)
8900            .use_s3_express_control_endpoint(false)
8901            .build()
8902            .expect("invalid params");
8903        let resolver = crate::config::endpoint::DefaultResolver::new();
8904        let endpoint = resolver.resolve_endpoint(&params);
8905        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad format error]");
8906        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
8907    }
8908
8909    /// bad format error no session auth
8910    #[test]
8911    fn test_305() {
8912        let params = crate::config::endpoint::Params::builder()
8913            .region("us-east-1".to_string())
8914            .bucket("mybucket--usaz1--x-s3".to_string())
8915            .use_fips(false)
8916            .use_dual_stack(false)
8917            .accelerate(false)
8918            .use_s3_express_control_endpoint(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 error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad format error no session auth]");
8925        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
8926    }
8927
8928    /// dual-stack error
8929    #[test]
8930    fn test_306() {
8931        let params = crate::config::endpoint::Params::builder()
8932            .region("us-east-1".to_string())
8933            .bucket("mybucket--test-ab1--x-s3".to_string())
8934            .use_fips(false)
8935            .use_dual_stack(true)
8936            .accelerate(false)
8937            .use_s3_express_control_endpoint(false)
8938            .build()
8939            .expect("invalid params");
8940        let resolver = crate::config::endpoint::DefaultResolver::new();
8941        let endpoint = resolver.resolve_endpoint(&params);
8942        let error = endpoint.expect_err("expected error: S3Express does not support Dual-stack. [dual-stack error]");
8943        assert_eq!(format!("{}", error), "S3Express does not support Dual-stack.")
8944    }
8945
8946    /// accelerate error
8947    #[test]
8948    fn test_307() {
8949        let params = crate::config::endpoint::Params::builder()
8950            .region("us-east-1".to_string())
8951            .bucket("mybucket--test-ab1--x-s3".to_string())
8952            .use_fips(false)
8953            .use_dual_stack(false)
8954            .accelerate(true)
8955            .use_s3_express_control_endpoint(false)
8956            .build()
8957            .expect("invalid params");
8958        let resolver = crate::config::endpoint::DefaultResolver::new();
8959        let endpoint = resolver.resolve_endpoint(&params);
8960        let error = endpoint.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error]");
8961        assert_eq!(format!("{}", error), "S3Express does not support S3 Accelerate.")
8962    }
8963
8964    /// Data plane bucket format error
8965    #[test]
8966    fn test_308() {
8967        let params = crate::config::endpoint::Params::builder()
8968            .region("us-east-1".to_string())
8969            .bucket("my.bucket--test-ab1--x-s3".to_string())
8970            .use_fips(false)
8971            .use_dual_stack(false)
8972            .accelerate(false)
8973            .use_s3_express_control_endpoint(false)
8974            .build()
8975            .expect("invalid params");
8976        let resolver = crate::config::endpoint::DefaultResolver::new();
8977        let endpoint = resolver.resolve_endpoint(&params);
8978        let error =
8979            endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane bucket format error]");
8980        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8981    }
8982
8983    /// host override data plane bucket error session auth
8984    #[test]
8985    fn test_309() {
8986        let params = crate::config::endpoint::Params::builder()
8987            .region("us-west-2".to_string())
8988            .bucket("my.bucket--usw2-az1--x-s3".to_string())
8989            .use_fips(false)
8990            .use_dual_stack(false)
8991            .accelerate(false)
8992            .endpoint("https://custom.com".to_string())
8993            .build()
8994            .expect("invalid params");
8995        let resolver = crate::config::endpoint::DefaultResolver::new();
8996        let endpoint = resolver.resolve_endpoint(&params);
8997        let error = endpoint.expect_err(
8998            "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error session auth]",
8999        );
9000        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
9001    }
9002
9003    /// host override data plane bucket error
9004    #[test]
9005    fn test_310() {
9006        let params = crate::config::endpoint::Params::builder()
9007            .region("us-west-2".to_string())
9008            .bucket("my.bucket--usw2-az1--x-s3".to_string())
9009            .use_fips(false)
9010            .use_dual_stack(false)
9011            .accelerate(false)
9012            .endpoint("https://custom.com".to_string())
9013            .disable_s3_express_session_auth(true)
9014            .build()
9015            .expect("invalid params");
9016        let resolver = crate::config::endpoint::DefaultResolver::new();
9017        let endpoint = resolver.resolve_endpoint(&params);
9018        let error = endpoint
9019            .expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error]");
9020        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
9021    }
9022}
9023
9024/// Endpoint resolver trait specific to Amazon Simple Storage Service
9025pub trait ResolveEndpoint: ::std::marker::Send + ::std::marker::Sync + ::std::fmt::Debug {
9026    /// Resolve an endpoint with the given parameters
9027    fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a>;
9028
9029    /// Convert this service-specific resolver into a `SharedEndpointResolver`
9030    ///
9031    /// The resulting resolver will downcast `EndpointResolverParams` into `crate::config::endpoint::Params`.
9032    fn into_shared_resolver(self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver
9033    where
9034        Self: Sized + 'static,
9035    {
9036        ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
9037    }
9038}
9039
9040#[derive(Debug)]
9041struct DowncastParams<T>(T);
9042impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
9043where
9044    T: ResolveEndpoint,
9045{
9046    fn resolve_endpoint<'a>(
9047        &'a self,
9048        params: &'a ::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams,
9049    ) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
9050        let ep = match params.get::<crate::config::endpoint::Params>() {
9051            Some(params) => self.0.resolve_endpoint(params),
9052            None => ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(Err("params of expected type was not present".into())),
9053        };
9054        ep
9055    }
9056}
9057
9058/// The default endpoint resolver
9059#[derive(Debug, Default)]
9060pub struct DefaultResolver {
9061    partition_resolver: crate::endpoint_lib::partition::PartitionResolver,
9062}
9063
9064impl DefaultResolver {
9065    /// Create a new endpoint resolver with default settings
9066    pub fn new() -> Self {
9067        Self {
9068            partition_resolver: crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER.clone(),
9069        }
9070    }
9071
9072    fn resolve_endpoint(
9073        &self,
9074        params: &crate::config::endpoint::Params,
9075    ) -> Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_runtime_api::box_error::BoxError> {
9076        let mut diagnostic_collector = crate::endpoint_lib::diagnostic::DiagnosticCollector::new();
9077        Ok(
9078            crate::config::endpoint::internals::resolve_endpoint(params, &mut diagnostic_collector, &self.partition_resolver)
9079                .map_err(|err| err.with_source(diagnostic_collector.take_last_error()))?,
9080        )
9081    }
9082}
9083
9084impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
9085    fn resolve_endpoint(&self, params: &crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture {
9086        ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(self.resolve_endpoint(params))
9087    }
9088}
9089
9090#[non_exhaustive]
9091#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
9092/// Configuration parameters for resolving the correct endpoint
9093pub struct Params {
9094    /// 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.
9095    pub(crate) bucket: ::std::option::Option<::std::string::String>,
9096    /// The AWS region used to dispatch the request.
9097    pub(crate) region: ::std::option::Option<::std::string::String>,
9098    /// 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.
9099    pub(crate) use_fips: bool,
9100    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
9101    pub(crate) use_dual_stack: bool,
9102    /// Override the endpoint used to send this request
9103    pub(crate) endpoint: ::std::option::Option<::std::string::String>,
9104    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
9105    pub(crate) force_path_style: bool,
9106    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
9107    pub(crate) accelerate: bool,
9108    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
9109    pub(crate) use_global_endpoint: bool,
9110    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
9111    pub(crate) use_object_lambda_endpoint: ::std::option::Option<bool>,
9112    /// 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.
9113    pub(crate) key: ::std::option::Option<::std::string::String>,
9114    /// 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.
9115    pub(crate) prefix: ::std::option::Option<::std::string::String>,
9116    /// 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.
9117    pub(crate) copy_source: ::std::option::Option<::std::string::String>,
9118    /// Internal parameter to disable Access Point Buckets
9119    pub(crate) disable_access_points: ::std::option::Option<bool>,
9120    /// Whether multi-region access points (MRAP) should be disabled.
9121    pub(crate) disable_multi_region_access_points: bool,
9122    /// 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.
9123    pub(crate) use_arn_region: ::std::option::Option<bool>,
9124    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
9125    pub(crate) use_s3_express_control_endpoint: ::std::option::Option<bool>,
9126    /// Parameter to indicate whether S3Express session auth should be disabled
9127    pub(crate) disable_s3_express_session_auth: ::std::option::Option<bool>,
9128}
9129impl Params {
9130    /// Create a builder for [`Params`]
9131    pub fn builder() -> crate::config::endpoint::ParamsBuilder {
9132        crate::config::endpoint::ParamsBuilder::default()
9133    }
9134    /// 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.
9135    pub fn bucket(&self) -> ::std::option::Option<&str> {
9136        self.bucket.as_deref()
9137    }
9138    /// The AWS region used to dispatch the request.
9139    pub fn region(&self) -> ::std::option::Option<&str> {
9140        self.region.as_deref()
9141    }
9142    /// 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.
9143    pub fn use_fips(&self) -> ::std::option::Option<bool> {
9144        Some(self.use_fips)
9145    }
9146    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
9147    pub fn use_dual_stack(&self) -> ::std::option::Option<bool> {
9148        Some(self.use_dual_stack)
9149    }
9150    /// Override the endpoint used to send this request
9151    pub fn endpoint(&self) -> ::std::option::Option<&str> {
9152        self.endpoint.as_deref()
9153    }
9154    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
9155    pub fn force_path_style(&self) -> ::std::option::Option<bool> {
9156        Some(self.force_path_style)
9157    }
9158    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
9159    pub fn accelerate(&self) -> ::std::option::Option<bool> {
9160        Some(self.accelerate)
9161    }
9162    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
9163    pub fn use_global_endpoint(&self) -> ::std::option::Option<bool> {
9164        Some(self.use_global_endpoint)
9165    }
9166    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
9167    pub fn use_object_lambda_endpoint(&self) -> ::std::option::Option<bool> {
9168        self.use_object_lambda_endpoint
9169    }
9170    /// 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.
9171    pub fn key(&self) -> ::std::option::Option<&str> {
9172        self.key.as_deref()
9173    }
9174    /// 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.
9175    pub fn prefix(&self) -> ::std::option::Option<&str> {
9176        self.prefix.as_deref()
9177    }
9178    /// 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.
9179    pub fn copy_source(&self) -> ::std::option::Option<&str> {
9180        self.copy_source.as_deref()
9181    }
9182    /// Internal parameter to disable Access Point Buckets
9183    pub fn disable_access_points(&self) -> ::std::option::Option<bool> {
9184        self.disable_access_points
9185    }
9186    /// Whether multi-region access points (MRAP) should be disabled.
9187    pub fn disable_multi_region_access_points(&self) -> ::std::option::Option<bool> {
9188        Some(self.disable_multi_region_access_points)
9189    }
9190    /// 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.
9191    pub fn use_arn_region(&self) -> ::std::option::Option<bool> {
9192        self.use_arn_region
9193    }
9194    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
9195    pub fn use_s3_express_control_endpoint(&self) -> ::std::option::Option<bool> {
9196        self.use_s3_express_control_endpoint
9197    }
9198    /// Parameter to indicate whether S3Express session auth should be disabled
9199    pub fn disable_s3_express_session_auth(&self) -> ::std::option::Option<bool> {
9200        self.disable_s3_express_session_auth
9201    }
9202}
9203
9204/// Builder for [`Params`]
9205#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
9206pub struct ParamsBuilder {
9207    bucket: ::std::option::Option<::std::string::String>,
9208    region: ::std::option::Option<::std::string::String>,
9209    use_fips: ::std::option::Option<bool>,
9210    use_dual_stack: ::std::option::Option<bool>,
9211    endpoint: ::std::option::Option<::std::string::String>,
9212    force_path_style: ::std::option::Option<bool>,
9213    accelerate: ::std::option::Option<bool>,
9214    use_global_endpoint: ::std::option::Option<bool>,
9215    use_object_lambda_endpoint: ::std::option::Option<bool>,
9216    key: ::std::option::Option<::std::string::String>,
9217    prefix: ::std::option::Option<::std::string::String>,
9218    copy_source: ::std::option::Option<::std::string::String>,
9219    disable_access_points: ::std::option::Option<bool>,
9220    disable_multi_region_access_points: ::std::option::Option<bool>,
9221    use_arn_region: ::std::option::Option<bool>,
9222    use_s3_express_control_endpoint: ::std::option::Option<bool>,
9223    disable_s3_express_session_auth: ::std::option::Option<bool>,
9224}
9225impl ParamsBuilder {
9226    /// Consume this builder, creating [`Params`].
9227    pub fn build(self) -> ::std::result::Result<crate::config::endpoint::Params, crate::config::endpoint::InvalidParams> {
9228        Ok(
9229            #[allow(clippy::unnecessary_lazy_evaluations)]
9230            crate::config::endpoint::Params {
9231                bucket: self.bucket,
9232                region: self.region,
9233                use_fips: self
9234                    .use_fips
9235                    .or_else(|| Some(false))
9236                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_fips"))?,
9237                use_dual_stack: self
9238                    .use_dual_stack
9239                    .or_else(|| Some(false))
9240                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_dual_stack"))?,
9241                endpoint: self.endpoint,
9242                force_path_style: self
9243                    .force_path_style
9244                    .or_else(|| Some(false))
9245                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("force_path_style"))?,
9246                accelerate: self
9247                    .accelerate
9248                    .or_else(|| Some(false))
9249                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("accelerate"))?,
9250                use_global_endpoint: self
9251                    .use_global_endpoint
9252                    .or_else(|| Some(false))
9253                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_global_endpoint"))?,
9254                use_object_lambda_endpoint: self.use_object_lambda_endpoint,
9255                key: self.key,
9256                prefix: self.prefix,
9257                copy_source: self.copy_source,
9258                disable_access_points: self.disable_access_points,
9259                disable_multi_region_access_points: self
9260                    .disable_multi_region_access_points
9261                    .or_else(|| Some(false))
9262                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("disable_multi_region_access_points"))?,
9263                use_arn_region: self.use_arn_region,
9264                use_s3_express_control_endpoint: self.use_s3_express_control_endpoint,
9265                disable_s3_express_session_auth: self.disable_s3_express_session_auth,
9266            },
9267        )
9268    }
9269    /// Sets the value for bucket
9270    ///
9271    /// 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.
9272    pub fn bucket(mut self, value: impl Into<::std::string::String>) -> Self {
9273        self.bucket = Some(value.into());
9274        self
9275    }
9276
9277    /// Sets the value for bucket
9278    ///
9279    /// 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.
9280    pub fn set_bucket(mut self, param: Option<::std::string::String>) -> Self {
9281        self.bucket = param;
9282        self
9283    }
9284    /// Sets the value for region
9285    ///
9286    /// The AWS region used to dispatch the request.
9287    pub fn region(mut self, value: impl Into<::std::string::String>) -> Self {
9288        self.region = Some(value.into());
9289        self
9290    }
9291
9292    /// Sets the value for region
9293    ///
9294    /// The AWS region used to dispatch the request.
9295    pub fn set_region(mut self, param: Option<::std::string::String>) -> Self {
9296        self.region = param;
9297        self
9298    }
9299    /// Sets the value for use_fips
9300    ///
9301    /// When unset, this parameter has a default value of `false`.
9302    /// 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.
9303    pub fn use_fips(mut self, value: impl Into<bool>) -> Self {
9304        self.use_fips = Some(value.into());
9305        self
9306    }
9307
9308    /// Sets the value for use_fips
9309    ///
9310    /// When unset, this parameter has a default value of `false`.
9311    /// 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.
9312    pub fn set_use_fips(mut self, param: Option<bool>) -> Self {
9313        self.use_fips = param;
9314        self
9315    }
9316    /// Sets the value for use_dual_stack
9317    ///
9318    /// When unset, this parameter has a default value of `false`.
9319    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
9320    pub fn use_dual_stack(mut self, value: impl Into<bool>) -> Self {
9321        self.use_dual_stack = Some(value.into());
9322        self
9323    }
9324
9325    /// Sets the value for use_dual_stack
9326    ///
9327    /// When unset, this parameter has a default value of `false`.
9328    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
9329    pub fn set_use_dual_stack(mut self, param: Option<bool>) -> Self {
9330        self.use_dual_stack = param;
9331        self
9332    }
9333    /// Sets the value for endpoint
9334    ///
9335    /// Override the endpoint used to send this request
9336    pub fn endpoint(mut self, value: impl Into<::std::string::String>) -> Self {
9337        self.endpoint = Some(value.into());
9338        self
9339    }
9340
9341    /// Sets the value for endpoint
9342    ///
9343    /// Override the endpoint used to send this request
9344    pub fn set_endpoint(mut self, param: Option<::std::string::String>) -> Self {
9345        self.endpoint = param;
9346        self
9347    }
9348    /// Sets the value for force_path_style
9349    ///
9350    /// When unset, this parameter has a default value of `false`.
9351    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
9352    pub fn force_path_style(mut self, value: impl Into<bool>) -> Self {
9353        self.force_path_style = Some(value.into());
9354        self
9355    }
9356
9357    /// Sets the value for force_path_style
9358    ///
9359    /// When unset, this parameter has a default value of `false`.
9360    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
9361    pub fn set_force_path_style(mut self, param: Option<bool>) -> Self {
9362        self.force_path_style = param;
9363        self
9364    }
9365    /// Sets the value for accelerate
9366    ///
9367    /// When unset, this parameter has a default value of `false`.
9368    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
9369    pub fn accelerate(mut self, value: impl Into<bool>) -> Self {
9370        self.accelerate = Some(value.into());
9371        self
9372    }
9373
9374    /// Sets the value for accelerate
9375    ///
9376    /// When unset, this parameter has a default value of `false`.
9377    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
9378    pub fn set_accelerate(mut self, param: Option<bool>) -> Self {
9379        self.accelerate = param;
9380        self
9381    }
9382    /// Sets the value for use_global_endpoint
9383    ///
9384    /// When unset, this parameter has a default value of `false`.
9385    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
9386    pub fn use_global_endpoint(mut self, value: impl Into<bool>) -> Self {
9387        self.use_global_endpoint = Some(value.into());
9388        self
9389    }
9390
9391    /// Sets the value for use_global_endpoint
9392    ///
9393    /// When unset, this parameter has a default value of `false`.
9394    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
9395    pub fn set_use_global_endpoint(mut self, param: Option<bool>) -> Self {
9396        self.use_global_endpoint = param;
9397        self
9398    }
9399    /// Sets the value for use_object_lambda_endpoint
9400    ///
9401    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
9402    pub fn use_object_lambda_endpoint(mut self, value: impl Into<bool>) -> Self {
9403        self.use_object_lambda_endpoint = Some(value.into());
9404        self
9405    }
9406
9407    /// Sets the value for use_object_lambda_endpoint
9408    ///
9409    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
9410    pub fn set_use_object_lambda_endpoint(mut self, param: Option<bool>) -> Self {
9411        self.use_object_lambda_endpoint = param;
9412        self
9413    }
9414    /// Sets the value for key
9415    ///
9416    /// 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.
9417    pub fn key(mut self, value: impl Into<::std::string::String>) -> Self {
9418        self.key = Some(value.into());
9419        self
9420    }
9421
9422    /// Sets the value for key
9423    ///
9424    /// 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.
9425    pub fn set_key(mut self, param: Option<::std::string::String>) -> Self {
9426        self.key = param;
9427        self
9428    }
9429    /// Sets the value for prefix
9430    ///
9431    /// 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.
9432    pub fn prefix(mut self, value: impl Into<::std::string::String>) -> Self {
9433        self.prefix = Some(value.into());
9434        self
9435    }
9436
9437    /// Sets the value for prefix
9438    ///
9439    /// 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.
9440    pub fn set_prefix(mut self, param: Option<::std::string::String>) -> Self {
9441        self.prefix = param;
9442        self
9443    }
9444    /// Sets the value for copy_source
9445    ///
9446    /// 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.
9447    pub fn copy_source(mut self, value: impl Into<::std::string::String>) -> Self {
9448        self.copy_source = Some(value.into());
9449        self
9450    }
9451
9452    /// Sets the value for copy_source
9453    ///
9454    /// 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.
9455    pub fn set_copy_source(mut self, param: Option<::std::string::String>) -> Self {
9456        self.copy_source = param;
9457        self
9458    }
9459    /// Sets the value for disable_access_points
9460    ///
9461    /// Internal parameter to disable Access Point Buckets
9462    pub fn disable_access_points(mut self, value: impl Into<bool>) -> Self {
9463        self.disable_access_points = Some(value.into());
9464        self
9465    }
9466
9467    /// Sets the value for disable_access_points
9468    ///
9469    /// Internal parameter to disable Access Point Buckets
9470    pub fn set_disable_access_points(mut self, param: Option<bool>) -> Self {
9471        self.disable_access_points = param;
9472        self
9473    }
9474    /// Sets the value for disable_multi_region_access_points
9475    ///
9476    /// When unset, this parameter has a default value of `false`.
9477    /// Whether multi-region access points (MRAP) should be disabled.
9478    pub fn disable_multi_region_access_points(mut self, value: impl Into<bool>) -> Self {
9479        self.disable_multi_region_access_points = Some(value.into());
9480        self
9481    }
9482
9483    /// Sets the value for disable_multi_region_access_points
9484    ///
9485    /// When unset, this parameter has a default value of `false`.
9486    /// Whether multi-region access points (MRAP) should be disabled.
9487    pub fn set_disable_multi_region_access_points(mut self, param: Option<bool>) -> Self {
9488        self.disable_multi_region_access_points = param;
9489        self
9490    }
9491    /// Sets the value for use_arn_region
9492    ///
9493    /// 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.
9494    pub fn use_arn_region(mut self, value: impl Into<bool>) -> Self {
9495        self.use_arn_region = Some(value.into());
9496        self
9497    }
9498
9499    /// Sets the value for use_arn_region
9500    ///
9501    /// 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.
9502    pub fn set_use_arn_region(mut self, param: Option<bool>) -> Self {
9503        self.use_arn_region = param;
9504        self
9505    }
9506    /// Sets the value for use_s3_express_control_endpoint
9507    ///
9508    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
9509    pub fn use_s3_express_control_endpoint(mut self, value: impl Into<bool>) -> Self {
9510        self.use_s3_express_control_endpoint = Some(value.into());
9511        self
9512    }
9513
9514    /// Sets the value for use_s3_express_control_endpoint
9515    ///
9516    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
9517    pub fn set_use_s3_express_control_endpoint(mut self, param: Option<bool>) -> Self {
9518        self.use_s3_express_control_endpoint = param;
9519        self
9520    }
9521    /// Sets the value for disable_s3_express_session_auth
9522    ///
9523    /// Parameter to indicate whether S3Express session auth should be disabled
9524    pub fn disable_s3_express_session_auth(mut self, value: impl Into<bool>) -> Self {
9525        self.disable_s3_express_session_auth = Some(value.into());
9526        self
9527    }
9528
9529    /// Sets the value for disable_s3_express_session_auth
9530    ///
9531    /// Parameter to indicate whether S3Express session auth should be disabled
9532    pub fn set_disable_s3_express_session_auth(mut self, param: Option<bool>) -> Self {
9533        self.disable_s3_express_session_auth = param;
9534        self
9535    }
9536}
9537
9538/// An error that occurred during endpoint resolution
9539#[derive(Debug)]
9540pub struct InvalidParams {
9541    field: std::borrow::Cow<'static, str>,
9542}
9543
9544impl InvalidParams {
9545    #[allow(dead_code)]
9546    fn missing(field: &'static str) -> Self {
9547        Self { field: field.into() }
9548    }
9549}
9550
9551impl std::fmt::Display for InvalidParams {
9552    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9553        write!(f, "a required field was missing: `{}`", self.field)
9554    }
9555}
9556
9557impl std::error::Error for InvalidParams {}
9558
9559mod internals;
aws_sdk_s3/config/endpoint.rs

aws_sdk_s3/config/
endpoint.rs
