aws_sdk_s3/config/
endpoint.rs

Help
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///
7#[cfg(test)]
8mod test {
9
10    /// region is not a valid DNS-suffix
11    #[test]
12    fn test_1() {
13        let params = crate::config::endpoint::Params::builder()
14            .region("a b".to_string())
15            .use_fips(false)
16            .use_dual_stack(false)
17            .accelerate(false)
18            .build()
19            .expect("invalid params");
20        let resolver = crate::config::endpoint::DefaultResolver::new();
21        let endpoint = resolver.resolve_endpoint(&params);
22        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [region is not a valid DNS-suffix]");
23        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
24    }
25
26    /// Invalid access point ARN: Not S3
27    #[test]
28    fn test_2() {
29        let params = crate::config::endpoint::Params::builder()
30            .region("us-east-1".to_string())
31            .use_fips(false)
32            .use_dual_stack(false)
33            .accelerate(false)
34            .bucket("arn:aws:not-s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
35            .build()
36            .expect("invalid params");
37        let resolver = crate::config::endpoint::DefaultResolver::new();
38        let endpoint = resolver.resolve_endpoint(&params);
39        let error =
40            endpoint.expect_err("expected error: Invalid ARN: The ARN was not for the S3 service, found: not-s3 [Invalid access point ARN: Not S3]");
41        assert_eq!(format!("{}", error), "Invalid ARN: The ARN was not for the S3 service, found: not-s3")
42    }
43
44    /// Invalid access point ARN: invalid resource
45    #[test]
46    fn test_3() {
47        let params = crate::config::endpoint::Params::builder()
48            .region("us-east-1".to_string())
49            .use_fips(false)
50            .use_dual_stack(false)
51            .accelerate(false)
52            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint:more-data".to_string())
53            .build()
54            .expect("invalid params");
55        let resolver = crate::config::endpoint::DefaultResolver::new();
56        let endpoint = resolver.resolve_endpoint(&params);
57        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]");
58        assert_eq!(
59            format!("{}", error),
60            "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`."
61        )
62    }
63
64    /// Invalid access point ARN: invalid no ap name
65    #[test]
66    fn test_4() {
67        let params = crate::config::endpoint::Params::builder()
68            .region("us-east-1".to_string())
69            .use_fips(false)
70            .use_dual_stack(false)
71            .accelerate(false)
72            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:".to_string())
73            .build()
74            .expect("invalid params");
75        let resolver = crate::config::endpoint::DefaultResolver::new();
76        let endpoint = resolver.resolve_endpoint(&params);
77        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]");
78        assert_eq!(
79            format!("{}", error),
80            "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided"
81        )
82    }
83
84    /// Invalid access point ARN: AccountId is invalid
85    #[test]
86    fn test_5() {
87        let params = crate::config::endpoint::Params::builder()
88            .region("us-east-1".to_string())
89            .use_fips(false)
90            .use_dual_stack(false)
91            .accelerate(false)
92            .bucket("arn:aws:s3:us-west-2:123456_789012:accesspoint:apname".to_string())
93            .build()
94            .expect("invalid params");
95        let resolver = crate::config::endpoint::DefaultResolver::new();
96        let endpoint = resolver.resolve_endpoint(&params);
97        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]");
98        assert_eq!(
99            format!("{}", error),
100            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123456_789012`"
101        )
102    }
103
104    /// Invalid access point ARN: access point name is invalid
105    #[test]
106    fn test_6() {
107        let params = crate::config::endpoint::Params::builder()
108            .region("us-east-1".to_string())
109            .use_fips(false)
110            .use_dual_stack(false)
111            .accelerate(false)
112            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:ap_name".to_string())
113            .build()
114            .expect("invalid params");
115        let resolver = crate::config::endpoint::DefaultResolver::new();
116        let endpoint = resolver.resolve_endpoint(&params);
117        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]");
118        assert_eq!(
119            format!("{}", error),
120            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `ap_name`"
121        )
122    }
123
124    /// Access points (disable access points explicitly false)
125    #[test]
126    fn test_7() {
127        let params = crate::config::endpoint::Params::builder()
128            .region("us-east-1".to_string())
129            .use_fips(false)
130            .use_dual_stack(false)
131            .accelerate(false)
132            .disable_access_points(false)
133            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
134            .build()
135            .expect("invalid params");
136        let resolver = crate::config::endpoint::DefaultResolver::new();
137        let endpoint = resolver.resolve_endpoint(&params);
138        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
139        assert_eq!(
140            endpoint,
141            ::aws_smithy_types::endpoint::Endpoint::builder()
142                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
143                .property(
144                    "authSchemes",
145                    vec![::aws_smithy_types::Document::from({
146                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
147                        out.insert("name".to_string(), "sigv4".to_string().into());
148                        out.insert("signingName".to_string(), "s3".to_string().into());
149                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
150                        out.insert("disableDoubleEncoding".to_string(), true.into());
151                        out
152                    })]
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![::aws_smithy_types::Document::from({
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                )
284                .build()
285        );
286    }
287
288    /// Access point ARN with Dualstack
289    #[test]
290    fn test_14() {
291        let params = crate::config::endpoint::Params::builder()
292            .region("us-east-1".to_string())
293            .use_fips(false)
294            .use_dual_stack(true)
295            .accelerate(false)
296            .disable_access_points(false)
297            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
298            .build()
299            .expect("invalid params");
300        let resolver = crate::config::endpoint::DefaultResolver::new();
301        let endpoint = resolver.resolve_endpoint(&params);
302        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.dualstack.us-west-2.amazonaws.com");
303        assert_eq!(
304            endpoint,
305            ::aws_smithy_types::endpoint::Endpoint::builder()
306                .url("https://myendpoint-123456789012.s3-accesspoint.dualstack.us-west-2.amazonaws.com")
307                .property(
308                    "authSchemes",
309                    vec![::aws_smithy_types::Document::from({
310                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
311                        out.insert("name".to_string(), "sigv4".to_string().into());
312                        out.insert("signingName".to_string(), "s3".to_string().into());
313                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
314                        out.insert("disableDoubleEncoding".to_string(), true.into());
315                        out
316                    })]
317                )
318                .build()
319        );
320    }
321
322    /// vanilla MRAP
323    #[test]
324    fn test_15() {
325        let params = crate::config::endpoint::Params::builder()
326            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
327            .region("us-east-1".to_string())
328            .disable_multi_region_access_points(false)
329            .use_fips(false)
330            .use_dual_stack(false)
331            .accelerate(false)
332            .build()
333            .expect("invalid params");
334        let resolver = crate::config::endpoint::DefaultResolver::new();
335        let endpoint = resolver.resolve_endpoint(&params);
336        let endpoint = endpoint.expect("Expected valid endpoint: https://mfzwi23gnjvgw.mrap.accesspoint.s3-global.amazonaws.com");
337        assert_eq!(
338            endpoint,
339            ::aws_smithy_types::endpoint::Endpoint::builder()
340                .url("https://mfzwi23gnjvgw.mrap.accesspoint.s3-global.amazonaws.com")
341                .property(
342                    "authSchemes",
343                    vec![::aws_smithy_types::Document::from({
344                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
345                        out.insert("name".to_string(), "sigv4a".to_string().into());
346                        out.insert(
347                            "signingRegionSet".to_string(),
348                            vec![::aws_smithy_types::Document::from("*".to_string())].into(),
349                        );
350                        out.insert("signingName".to_string(), "s3".to_string().into());
351                        out.insert("disableDoubleEncoding".to_string(), true.into());
352                        out
353                    })]
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![::aws_smithy_types::Document::from({
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                )
465                .build()
466        );
467    }
468
469    /// Dual-stack endpoint + SDK::Host is error
470    #[test]
471    fn test_21() {
472        let params = crate::config::endpoint::Params::builder()
473            .bucket("bucketname".to_string())
474            .region("us-west-2".to_string())
475            .force_path_style(true)
476            .use_fips(false)
477            .accelerate(false)
478            .use_dual_stack(true)
479            .endpoint("https://abc.com".to_string())
480            .build()
481            .expect("invalid params");
482        let resolver = crate::config::endpoint::DefaultResolver::new();
483        let endpoint = resolver.resolve_endpoint(&params);
484        let error = endpoint
485            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [Dual-stack endpoint + SDK::Host is error]");
486        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
487    }
488
489    /// path style + ARN bucket
490    #[test]
491    fn test_22() {
492        let params = crate::config::endpoint::Params::builder()
493            .accelerate(false)
494            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
495            .force_path_style(true)
496            .region("us-west-2".to_string())
497            .use_dual_stack(false)
498            .use_fips(false)
499            .build()
500            .expect("invalid params");
501        let resolver = crate::config::endpoint::DefaultResolver::new();
502        let endpoint = resolver.resolve_endpoint(&params);
503        let error = endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + ARN bucket]");
504        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
505    }
506
507    /// implicit path style bucket + dualstack
508    #[test]
509    fn test_23() {
510        let params = crate::config::endpoint::Params::builder()
511            .accelerate(false)
512            .bucket("99_ab".to_string())
513            .region("us-west-2".to_string())
514            .use_dual_stack(true)
515            .use_fips(false)
516            .build()
517            .expect("invalid params");
518        let resolver = crate::config::endpoint::DefaultResolver::new();
519        let endpoint = resolver.resolve_endpoint(&params);
520        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/99_ab");
521        assert_eq!(
522            endpoint,
523            ::aws_smithy_types::endpoint::Endpoint::builder()
524                .url("https://s3.dualstack.us-west-2.amazonaws.com/99_ab")
525                .property(
526                    "authSchemes",
527                    vec![::aws_smithy_types::Document::from({
528                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
529                        out.insert("name".to_string(), "sigv4".to_string().into());
530                        out.insert("signingName".to_string(), "s3".to_string().into());
531                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
532                        out.insert("disableDoubleEncoding".to_string(), true.into());
533                        out
534                    })]
535                )
536                .build()
537        );
538    }
539
540    /// implicit path style bucket + dualstack
541    #[test]
542    fn test_24() {
543        let params = crate::config::endpoint::Params::builder()
544            .accelerate(false)
545            .bucket("99_ab".to_string())
546            .region("us-west-2".to_string())
547            .use_dual_stack(true)
548            .use_fips(false)
549            .endpoint("http://abc.com".to_string())
550            .build()
551            .expect("invalid params");
552        let resolver = crate::config::endpoint::DefaultResolver::new();
553        let endpoint = resolver.resolve_endpoint(&params);
554        let error = endpoint
555            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [implicit path style bucket + dualstack]");
556        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
557    }
558
559    /// don't allow URL injections in the bucket
560    #[test]
561    fn test_25() {
562        let params = crate::config::endpoint::Params::builder()
563            .bucket("example.com#".to_string())
564            .region("us-west-2".to_string())
565            .use_dual_stack(false)
566            .use_fips(false)
567            .accelerate(false)
568            .build()
569            .expect("invalid params");
570        let resolver = crate::config::endpoint::DefaultResolver::new();
571        let endpoint = resolver.resolve_endpoint(&params);
572        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/example.com%23");
573        assert_eq!(
574            endpoint,
575            ::aws_smithy_types::endpoint::Endpoint::builder()
576                .url("https://s3.us-west-2.amazonaws.com/example.com%23")
577                .property(
578                    "authSchemes",
579                    vec![::aws_smithy_types::Document::from({
580                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
581                        out.insert("name".to_string(), "sigv4".to_string().into());
582                        out.insert("signingName".to_string(), "s3".to_string().into());
583                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
584                        out.insert("disableDoubleEncoding".to_string(), true.into());
585                        out
586                    })]
587                )
588                .build()
589        );
590    }
591
592    /// URI encode bucket names in the path
593    #[test]
594    fn test_26() {
595        let params = crate::config::endpoint::Params::builder()
596            .bucket("bucket name".to_string())
597            .region("us-west-2".to_string())
598            .use_dual_stack(false)
599            .use_fips(false)
600            .accelerate(false)
601            .build()
602            .expect("invalid params");
603        let resolver = crate::config::endpoint::DefaultResolver::new();
604        let endpoint = resolver.resolve_endpoint(&params);
605        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket%20name");
606        assert_eq!(
607            endpoint,
608            ::aws_smithy_types::endpoint::Endpoint::builder()
609                .url("https://s3.us-west-2.amazonaws.com/bucket%20name")
610                .property(
611                    "authSchemes",
612                    vec![::aws_smithy_types::Document::from({
613                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
614                        out.insert("name".to_string(), "sigv4".to_string().into());
615                        out.insert("signingName".to_string(), "s3".to_string().into());
616                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
617                        out.insert("disableDoubleEncoding".to_string(), true.into());
618                        out
619                    })]
620                )
621                .build()
622        );
623    }
624
625    /// scheme is respected
626    #[test]
627    fn test_27() {
628        let params = crate::config::endpoint::Params::builder()
629            .accelerate(false)
630            .bucket("99_ab".to_string())
631            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
632            .region("af-south-1".to_string())
633            .use_dual_stack(false)
634            .use_fips(false)
635            .build()
636            .expect("invalid params");
637        let resolver = crate::config::endpoint::DefaultResolver::new();
638        let endpoint = resolver.resolve_endpoint(&params);
639        let endpoint = endpoint.expect("Expected valid endpoint: http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab");
640        assert_eq!(
641            endpoint,
642            ::aws_smithy_types::endpoint::Endpoint::builder()
643                .url("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab")
644                .property(
645                    "authSchemes",
646                    vec![::aws_smithy_types::Document::from({
647                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
648                        out.insert("name".to_string(), "sigv4".to_string().into());
649                        out.insert("signingName".to_string(), "s3".to_string().into());
650                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
651                        out.insert("disableDoubleEncoding".to_string(), true.into());
652                        out
653                    })]
654                )
655                .build()
656        );
657    }
658
659    /// scheme is respected (virtual addressing)
660    #[test]
661    fn test_28() {
662        let params = crate::config::endpoint::Params::builder()
663            .accelerate(false)
664            .bucket("bucketname".to_string())
665            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo".to_string())
666            .region("af-south-1".to_string())
667            .use_dual_stack(false)
668            .use_fips(false)
669            .build()
670            .expect("invalid params");
671        let resolver = crate::config::endpoint::DefaultResolver::new();
672        let endpoint = resolver.resolve_endpoint(&params);
673        let endpoint = endpoint.expect("Expected valid endpoint: http://bucketname.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo");
674        assert_eq!(
675            endpoint,
676            ::aws_smithy_types::endpoint::Endpoint::builder()
677                .url("http://bucketname.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo")
678                .property(
679                    "authSchemes",
680                    vec![::aws_smithy_types::Document::from({
681                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
682                        out.insert("name".to_string(), "sigv4".to_string().into());
683                        out.insert("signingName".to_string(), "s3".to_string().into());
684                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
685                        out.insert("disableDoubleEncoding".to_string(), true.into());
686                        out
687                    })]
688                )
689                .build()
690        );
691    }
692
693    /// path style + implicit private link
694    #[test]
695    fn test_29() {
696        let params = crate::config::endpoint::Params::builder()
697            .accelerate(false)
698            .bucket("99_ab".to_string())
699            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
700            .region("af-south-1".to_string())
701            .use_dual_stack(false)
702            .use_fips(false)
703            .build()
704            .expect("invalid params");
705        let resolver = crate::config::endpoint::DefaultResolver::new();
706        let endpoint = resolver.resolve_endpoint(&params);
707        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab");
708        assert_eq!(
709            endpoint,
710            ::aws_smithy_types::endpoint::Endpoint::builder()
711                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab")
712                .property(
713                    "authSchemes",
714                    vec![::aws_smithy_types::Document::from({
715                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
716                        out.insert("name".to_string(), "sigv4".to_string().into());
717                        out.insert("signingName".to_string(), "s3".to_string().into());
718                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
719                        out.insert("disableDoubleEncoding".to_string(), true.into());
720                        out
721                    })]
722                )
723                .build()
724        );
725    }
726
727    /// invalid Endpoint override
728    #[test]
729    fn test_30() {
730        let params = crate::config::endpoint::Params::builder()
731            .accelerate(false)
732            .bucket("bucketname".to_string())
733            .endpoint("abcde://nota#url".to_string())
734            .region("af-south-1".to_string())
735            .use_dual_stack(false)
736            .use_fips(false)
737            .build()
738            .expect("invalid params");
739        let resolver = crate::config::endpoint::DefaultResolver::new();
740        let endpoint = resolver.resolve_endpoint(&params);
741        let error = endpoint.expect_err("expected error: Custom endpoint `abcde://nota#url` was not a valid URI [invalid Endpoint override]");
742        assert_eq!(format!("{}", error), "Custom endpoint `abcde://nota#url` was not a valid URI")
743    }
744
745    /// using an IPv4 address forces path style
746    #[test]
747    fn test_31() {
748        let params = crate::config::endpoint::Params::builder()
749            .accelerate(false)
750            .bucket("bucketname".to_string())
751            .endpoint("https://123.123.0.1".to_string())
752            .region("af-south-1".to_string())
753            .use_dual_stack(false)
754            .use_fips(false)
755            .build()
756            .expect("invalid params");
757        let resolver = crate::config::endpoint::DefaultResolver::new();
758        let endpoint = resolver.resolve_endpoint(&params);
759        let endpoint = endpoint.expect("Expected valid endpoint: https://123.123.0.1/bucketname");
760        assert_eq!(
761            endpoint,
762            ::aws_smithy_types::endpoint::Endpoint::builder()
763                .url("https://123.123.0.1/bucketname")
764                .property(
765                    "authSchemes",
766                    vec![::aws_smithy_types::Document::from({
767                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
768                        out.insert("name".to_string(), "sigv4".to_string().into());
769                        out.insert("signingName".to_string(), "s3".to_string().into());
770                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
771                        out.insert("disableDoubleEncoding".to_string(), true.into());
772                        out
773                    })]
774                )
775                .build()
776        );
777    }
778
779    /// vanilla access point arn with region mismatch and UseArnRegion=false
780    #[test]
781    fn test_32() {
782        let params = crate::config::endpoint::Params::builder()
783            .accelerate(false)
784            .bucket("arn:aws:s3:us-east-1:123456789012:accesspoint:myendpoint".to_string())
785            .force_path_style(false)
786            .use_arn_region(false)
787            .region("us-west-2".to_string())
788            .use_dual_stack(false)
789            .use_fips(false)
790            .build()
791            .expect("invalid params");
792        let resolver = crate::config::endpoint::DefaultResolver::new();
793        let endpoint = resolver.resolve_endpoint(&params);
794        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]");
795        assert_eq!(
796            format!("{}", error),
797            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
798        )
799    }
800
801    /// vanilla access point arn with region mismatch and UseArnRegion unset
802    #[test]
803    fn test_33() {
804        let params = crate::config::endpoint::Params::builder()
805            .accelerate(false)
806            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
807            .force_path_style(false)
808            .region("us-east-1".to_string())
809            .use_dual_stack(false)
810            .use_fips(false)
811            .build()
812            .expect("invalid params");
813        let resolver = crate::config::endpoint::DefaultResolver::new();
814        let endpoint = resolver.resolve_endpoint(&params);
815        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
816        assert_eq!(
817            endpoint,
818            ::aws_smithy_types::endpoint::Endpoint::builder()
819                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
820                .property(
821                    "authSchemes",
822                    vec![::aws_smithy_types::Document::from({
823                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
824                        out.insert("name".to_string(), "sigv4".to_string().into());
825                        out.insert("signingName".to_string(), "s3".to_string().into());
826                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
827                        out.insert("disableDoubleEncoding".to_string(), true.into());
828                        out
829                    })]
830                )
831                .build()
832        );
833    }
834
835    /// vanilla access point arn with region mismatch and UseArnRegion=true
836    #[test]
837    fn test_34() {
838        let params = crate::config::endpoint::Params::builder()
839            .accelerate(false)
840            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
841            .force_path_style(false)
842            .use_arn_region(true)
843            .region("us-east-1".to_string())
844            .use_dual_stack(false)
845            .use_fips(false)
846            .build()
847            .expect("invalid params");
848        let resolver = crate::config::endpoint::DefaultResolver::new();
849        let endpoint = resolver.resolve_endpoint(&params);
850        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
851        assert_eq!(
852            endpoint,
853            ::aws_smithy_types::endpoint::Endpoint::builder()
854                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
855                .property(
856                    "authSchemes",
857                    vec![::aws_smithy_types::Document::from({
858                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
859                        out.insert("name".to_string(), "sigv4".to_string().into());
860                        out.insert("signingName".to_string(), "s3".to_string().into());
861                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
862                        out.insert("disableDoubleEncoding".to_string(), true.into());
863                        out
864                    })]
865                )
866                .build()
867        );
868    }
869
870    /// subdomains are not allowed in virtual buckets
871    #[test]
872    fn test_35() {
873        let params = crate::config::endpoint::Params::builder()
874            .bucket("bucket.name".to_string())
875            .region("us-east-1".to_string())
876            .build()
877            .expect("invalid params");
878        let resolver = crate::config::endpoint::DefaultResolver::new();
879        let endpoint = resolver.resolve_endpoint(&params);
880        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/bucket.name");
881        assert_eq!(
882            endpoint,
883            ::aws_smithy_types::endpoint::Endpoint::builder()
884                .url("https://s3.us-east-1.amazonaws.com/bucket.name")
885                .property(
886                    "authSchemes",
887                    vec![::aws_smithy_types::Document::from({
888                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
889                        out.insert("name".to_string(), "sigv4".to_string().into());
890                        out.insert("signingName".to_string(), "s3".to_string().into());
891                        out.insert("disableDoubleEncoding".to_string(), true.into());
892                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
893                        out
894                    })]
895                )
896                .build()
897        );
898    }
899
900    /// bucket names with 3 characters are allowed in virtual buckets
901    #[test]
902    fn test_36() {
903        let params = crate::config::endpoint::Params::builder()
904            .bucket("aaa".to_string())
905            .region("us-east-1".to_string())
906            .build()
907            .expect("invalid params");
908        let resolver = crate::config::endpoint::DefaultResolver::new();
909        let endpoint = resolver.resolve_endpoint(&params);
910        let endpoint = endpoint.expect("Expected valid endpoint: https://aaa.s3.us-east-1.amazonaws.com");
911        assert_eq!(
912            endpoint,
913            ::aws_smithy_types::endpoint::Endpoint::builder()
914                .url("https://aaa.s3.us-east-1.amazonaws.com")
915                .property(
916                    "authSchemes",
917                    vec![::aws_smithy_types::Document::from({
918                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
919                        out.insert("name".to_string(), "sigv4".to_string().into());
920                        out.insert("signingName".to_string(), "s3".to_string().into());
921                        out.insert("disableDoubleEncoding".to_string(), true.into());
922                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
923                        out
924                    })]
925                )
926                .build()
927        );
928    }
929
930    /// bucket names with fewer than 3 characters are not allowed in virtual host
931    #[test]
932    fn test_37() {
933        let params = crate::config::endpoint::Params::builder()
934            .bucket("aa".to_string())
935            .region("us-east-1".to_string())
936            .build()
937            .expect("invalid params");
938        let resolver = crate::config::endpoint::DefaultResolver::new();
939        let endpoint = resolver.resolve_endpoint(&params);
940        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/aa");
941        assert_eq!(
942            endpoint,
943            ::aws_smithy_types::endpoint::Endpoint::builder()
944                .url("https://s3.us-east-1.amazonaws.com/aa")
945                .property(
946                    "authSchemes",
947                    vec![::aws_smithy_types::Document::from({
948                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
949                        out.insert("name".to_string(), "sigv4".to_string().into());
950                        out.insert("signingName".to_string(), "s3".to_string().into());
951                        out.insert("disableDoubleEncoding".to_string(), true.into());
952                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
953                        out
954                    })]
955                )
956                .build()
957        );
958    }
959
960    /// bucket names with uppercase characters are not allowed in virtual host
961    #[test]
962    fn test_38() {
963        let params = crate::config::endpoint::Params::builder()
964            .bucket("BucketName".to_string())
965            .region("us-east-1".to_string())
966            .build()
967            .expect("invalid params");
968        let resolver = crate::config::endpoint::DefaultResolver::new();
969        let endpoint = resolver.resolve_endpoint(&params);
970        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/BucketName");
971        assert_eq!(
972            endpoint,
973            ::aws_smithy_types::endpoint::Endpoint::builder()
974                .url("https://s3.us-east-1.amazonaws.com/BucketName")
975                .property(
976                    "authSchemes",
977                    vec![::aws_smithy_types::Document::from({
978                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
979                        out.insert("name".to_string(), "sigv4".to_string().into());
980                        out.insert("signingName".to_string(), "s3".to_string().into());
981                        out.insert("disableDoubleEncoding".to_string(), true.into());
982                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
983                        out
984                    })]
985                )
986                .build()
987        );
988    }
989
990    /// subdomains are allowed in virtual buckets on http endpoints
991    #[test]
992    fn test_39() {
993        let params = crate::config::endpoint::Params::builder()
994            .bucket("bucket.name".to_string())
995            .region("us-east-1".to_string())
996            .endpoint("http://example.com".to_string())
997            .build()
998            .expect("invalid params");
999        let resolver = crate::config::endpoint::DefaultResolver::new();
1000        let endpoint = resolver.resolve_endpoint(&params);
1001        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket.name.example.com");
1002        assert_eq!(
1003            endpoint,
1004            ::aws_smithy_types::endpoint::Endpoint::builder()
1005                .url("http://bucket.name.example.com")
1006                .property(
1007                    "authSchemes",
1008                    vec![::aws_smithy_types::Document::from({
1009                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1010                        out.insert("name".to_string(), "sigv4".to_string().into());
1011                        out.insert("signingName".to_string(), "s3".to_string().into());
1012                        out.insert("disableDoubleEncoding".to_string(), true.into());
1013                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1014                        out
1015                    })]
1016                )
1017                .build()
1018        );
1019    }
1020
1021    /// no region set
1022    #[test]
1023    fn test_40() {
1024        let params = crate::config::endpoint::Params::builder()
1025            .bucket("bucket-name".to_string())
1026            .build()
1027            .expect("invalid params");
1028        let resolver = crate::config::endpoint::DefaultResolver::new();
1029        let endpoint = resolver.resolve_endpoint(&params);
1030        let error = endpoint.expect_err("expected error: A region must be set when sending requests to S3. [no region set]");
1031        assert_eq!(format!("{}", error), "A region must be set when sending requests to S3.")
1032    }
1033
1034    /// UseGlobalEndpoints=true, region=us-east-1 uses the global endpoint
1035    #[test]
1036    fn test_41() {
1037        let params = crate::config::endpoint::Params::builder()
1038            .region("us-east-1".to_string())
1039            .use_global_endpoint(true)
1040            .use_fips(false)
1041            .use_dual_stack(false)
1042            .accelerate(false)
1043            .build()
1044            .expect("invalid params");
1045        let resolver = crate::config::endpoint::DefaultResolver::new();
1046        let endpoint = resolver.resolve_endpoint(&params);
1047        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1048        assert_eq!(
1049            endpoint,
1050            ::aws_smithy_types::endpoint::Endpoint::builder()
1051                .url("https://s3.amazonaws.com")
1052                .property(
1053                    "authSchemes",
1054                    vec![::aws_smithy_types::Document::from({
1055                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1056                        out.insert("name".to_string(), "sigv4".to_string().into());
1057                        out.insert("signingName".to_string(), "s3".to_string().into());
1058                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1059                        out.insert("disableDoubleEncoding".to_string(), true.into());
1060                        out
1061                    })]
1062                )
1063                .build()
1064        );
1065    }
1066
1067    /// UseGlobalEndpoints=true, region=us-west-2 uses the regional endpoint
1068    #[test]
1069    fn test_42() {
1070        let params = crate::config::endpoint::Params::builder()
1071            .region("us-west-2".to_string())
1072            .use_global_endpoint(true)
1073            .use_fips(false)
1074            .use_dual_stack(false)
1075            .accelerate(false)
1076            .build()
1077            .expect("invalid params");
1078        let resolver = crate::config::endpoint::DefaultResolver::new();
1079        let endpoint = resolver.resolve_endpoint(&params);
1080        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com");
1081        assert_eq!(
1082            endpoint,
1083            ::aws_smithy_types::endpoint::Endpoint::builder()
1084                .url("https://s3.us-west-2.amazonaws.com")
1085                .property(
1086                    "authSchemes",
1087                    vec![::aws_smithy_types::Document::from({
1088                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1089                        out.insert("name".to_string(), "sigv4".to_string().into());
1090                        out.insert("signingName".to_string(), "s3".to_string().into());
1091                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
1092                        out.insert("disableDoubleEncoding".to_string(), true.into());
1093                        out
1094                    })]
1095                )
1096                .build()
1097        );
1098    }
1099
1100    /// UseGlobalEndpoints=true, region=cn-north-1 uses the regional endpoint
1101    #[test]
1102    fn test_43() {
1103        let params = crate::config::endpoint::Params::builder()
1104            .region("cn-north-1".to_string())
1105            .use_global_endpoint(true)
1106            .use_fips(false)
1107            .use_dual_stack(false)
1108            .accelerate(false)
1109            .build()
1110            .expect("invalid params");
1111        let resolver = crate::config::endpoint::DefaultResolver::new();
1112        let endpoint = resolver.resolve_endpoint(&params);
1113        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn");
1114        assert_eq!(
1115            endpoint,
1116            ::aws_smithy_types::endpoint::Endpoint::builder()
1117                .url("https://s3.cn-north-1.amazonaws.com.cn")
1118                .property(
1119                    "authSchemes",
1120                    vec![::aws_smithy_types::Document::from({
1121                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1122                        out.insert("name".to_string(), "sigv4".to_string().into());
1123                        out.insert("signingName".to_string(), "s3".to_string().into());
1124                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
1125                        out.insert("disableDoubleEncoding".to_string(), true.into());
1126                        out
1127                    })]
1128                )
1129                .build()
1130        );
1131    }
1132
1133    /// UseGlobalEndpoints=true, region=us-east-1, fips=true uses the regional endpoint with fips
1134    #[test]
1135    fn test_44() {
1136        let params = crate::config::endpoint::Params::builder()
1137            .region("us-east-1".to_string())
1138            .use_global_endpoint(true)
1139            .use_fips(true)
1140            .use_dual_stack(false)
1141            .accelerate(false)
1142            .build()
1143            .expect("invalid params");
1144        let resolver = crate::config::endpoint::DefaultResolver::new();
1145        let endpoint = resolver.resolve_endpoint(&params);
1146        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com");
1147        assert_eq!(
1148            endpoint,
1149            ::aws_smithy_types::endpoint::Endpoint::builder()
1150                .url("https://s3-fips.us-east-1.amazonaws.com")
1151                .property(
1152                    "authSchemes",
1153                    vec![::aws_smithy_types::Document::from({
1154                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1155                        out.insert("name".to_string(), "sigv4".to_string().into());
1156                        out.insert("signingName".to_string(), "s3".to_string().into());
1157                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1158                        out.insert("disableDoubleEncoding".to_string(), true.into());
1159                        out
1160                    })]
1161                )
1162                .build()
1163        );
1164    }
1165
1166    /// UseGlobalEndpoints=true, region=us-east-1, dualstack=true uses the regional endpoint with dualstack
1167    #[test]
1168    fn test_45() {
1169        let params = crate::config::endpoint::Params::builder()
1170            .region("us-east-1".to_string())
1171            .use_global_endpoint(true)
1172            .use_fips(false)
1173            .use_dual_stack(true)
1174            .accelerate(false)
1175            .build()
1176            .expect("invalid params");
1177        let resolver = crate::config::endpoint::DefaultResolver::new();
1178        let endpoint = resolver.resolve_endpoint(&params);
1179        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com");
1180        assert_eq!(
1181            endpoint,
1182            ::aws_smithy_types::endpoint::Endpoint::builder()
1183                .url("https://s3.dualstack.us-east-1.amazonaws.com")
1184                .property(
1185                    "authSchemes",
1186                    vec![::aws_smithy_types::Document::from({
1187                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1188                        out.insert("name".to_string(), "sigv4".to_string().into());
1189                        out.insert("signingName".to_string(), "s3".to_string().into());
1190                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1191                        out.insert("disableDoubleEncoding".to_string(), true.into());
1192                        out
1193                    })]
1194                )
1195                .build()
1196        );
1197    }
1198
1199    /// UseGlobalEndpoints=true, region=us-east-1, dualstack and fips uses the regional endpoint with fips/dualstack
1200    #[test]
1201    fn test_46() {
1202        let params = crate::config::endpoint::Params::builder()
1203            .region("us-east-1".to_string())
1204            .use_global_endpoint(true)
1205            .use_fips(true)
1206            .use_dual_stack(true)
1207            .accelerate(false)
1208            .build()
1209            .expect("invalid params");
1210        let resolver = crate::config::endpoint::DefaultResolver::new();
1211        let endpoint = resolver.resolve_endpoint(&params);
1212        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com");
1213        assert_eq!(
1214            endpoint,
1215            ::aws_smithy_types::endpoint::Endpoint::builder()
1216                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com")
1217                .property(
1218                    "authSchemes",
1219                    vec![::aws_smithy_types::Document::from({
1220                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1221                        out.insert("name".to_string(), "sigv4".to_string().into());
1222                        out.insert("signingName".to_string(), "s3".to_string().into());
1223                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1224                        out.insert("disableDoubleEncoding".to_string(), true.into());
1225                        out
1226                    })]
1227                )
1228                .build()
1229        );
1230    }
1231
1232    /// UseGlobalEndpoints=true, region=us-east-1 with custom endpoint, uses custom
1233    #[test]
1234    fn test_47() {
1235        let params = crate::config::endpoint::Params::builder()
1236            .region("us-east-1".to_string())
1237            .endpoint("https://example.com".to_string())
1238            .use_global_endpoint(true)
1239            .use_fips(false)
1240            .use_dual_stack(false)
1241            .accelerate(false)
1242            .build()
1243            .expect("invalid params");
1244        let resolver = crate::config::endpoint::DefaultResolver::new();
1245        let endpoint = resolver.resolve_endpoint(&params);
1246        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1247        assert_eq!(
1248            endpoint,
1249            ::aws_smithy_types::endpoint::Endpoint::builder()
1250                .url("https://example.com")
1251                .property(
1252                    "authSchemes",
1253                    vec![::aws_smithy_types::Document::from({
1254                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1255                        out.insert("name".to_string(), "sigv4".to_string().into());
1256                        out.insert("signingName".to_string(), "s3".to_string().into());
1257                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1258                        out.insert("disableDoubleEncoding".to_string(), true.into());
1259                        out
1260                    })]
1261                )
1262                .build()
1263        );
1264    }
1265
1266    /// UseGlobalEndpoints=true, region=us-west-2 with custom endpoint, uses custom
1267    #[test]
1268    fn test_48() {
1269        let params = crate::config::endpoint::Params::builder()
1270            .region("us-west-2".to_string())
1271            .endpoint("https://example.com".to_string())
1272            .use_global_endpoint(true)
1273            .use_fips(false)
1274            .use_dual_stack(false)
1275            .accelerate(false)
1276            .build()
1277            .expect("invalid params");
1278        let resolver = crate::config::endpoint::DefaultResolver::new();
1279        let endpoint = resolver.resolve_endpoint(&params);
1280        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1281        assert_eq!(
1282            endpoint,
1283            ::aws_smithy_types::endpoint::Endpoint::builder()
1284                .url("https://example.com")
1285                .property(
1286                    "authSchemes",
1287                    vec![::aws_smithy_types::Document::from({
1288                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1289                        out.insert("name".to_string(), "sigv4".to_string().into());
1290                        out.insert("signingName".to_string(), "s3".to_string().into());
1291                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
1292                        out.insert("disableDoubleEncoding".to_string(), true.into());
1293                        out
1294                    })]
1295                )
1296                .build()
1297        );
1298    }
1299
1300    /// UseGlobalEndpoints=true, region=us-east-1 with accelerate on non bucket case uses the global endpoint and ignores accelerate
1301    #[test]
1302    fn test_49() {
1303        let params = crate::config::endpoint::Params::builder()
1304            .region("us-east-1".to_string())
1305            .use_global_endpoint(true)
1306            .use_fips(false)
1307            .use_dual_stack(false)
1308            .accelerate(true)
1309            .build()
1310            .expect("invalid params");
1311        let resolver = crate::config::endpoint::DefaultResolver::new();
1312        let endpoint = resolver.resolve_endpoint(&params);
1313        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1314        assert_eq!(
1315            endpoint,
1316            ::aws_smithy_types::endpoint::Endpoint::builder()
1317                .url("https://s3.amazonaws.com")
1318                .property(
1319                    "authSchemes",
1320                    vec![::aws_smithy_types::Document::from({
1321                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1322                        out.insert("name".to_string(), "sigv4".to_string().into());
1323                        out.insert("signingName".to_string(), "s3".to_string().into());
1324                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1325                        out.insert("disableDoubleEncoding".to_string(), true.into());
1326                        out
1327                    })]
1328                )
1329                .build()
1330        );
1331    }
1332
1333    /// aws-global region uses the global endpoint
1334    #[test]
1335    fn test_50() {
1336        let params = crate::config::endpoint::Params::builder()
1337            .region("aws-global".to_string())
1338            .use_fips(false)
1339            .use_dual_stack(false)
1340            .accelerate(false)
1341            .build()
1342            .expect("invalid params");
1343        let resolver = crate::config::endpoint::DefaultResolver::new();
1344        let endpoint = resolver.resolve_endpoint(&params);
1345        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1346        assert_eq!(
1347            endpoint,
1348            ::aws_smithy_types::endpoint::Endpoint::builder()
1349                .url("https://s3.amazonaws.com")
1350                .property(
1351                    "authSchemes",
1352                    vec![::aws_smithy_types::Document::from({
1353                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1354                        out.insert("name".to_string(), "sigv4".to_string().into());
1355                        out.insert("signingName".to_string(), "s3".to_string().into());
1356                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1357                        out.insert("disableDoubleEncoding".to_string(), true.into());
1358                        out
1359                    })]
1360                )
1361                .build()
1362        );
1363    }
1364
1365    /// aws-global region with fips uses the regional endpoint
1366    #[test]
1367    fn test_51() {
1368        let params = crate::config::endpoint::Params::builder()
1369            .region("aws-global".to_string())
1370            .use_fips(true)
1371            .use_dual_stack(false)
1372            .accelerate(false)
1373            .build()
1374            .expect("invalid params");
1375        let resolver = crate::config::endpoint::DefaultResolver::new();
1376        let endpoint = resolver.resolve_endpoint(&params);
1377        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com");
1378        assert_eq!(
1379            endpoint,
1380            ::aws_smithy_types::endpoint::Endpoint::builder()
1381                .url("https://s3-fips.us-east-1.amazonaws.com")
1382                .property(
1383                    "authSchemes",
1384                    vec![::aws_smithy_types::Document::from({
1385                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1386                        out.insert("name".to_string(), "sigv4".to_string().into());
1387                        out.insert("signingName".to_string(), "s3".to_string().into());
1388                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1389                        out.insert("disableDoubleEncoding".to_string(), true.into());
1390                        out
1391                    })]
1392                )
1393                .build()
1394        );
1395    }
1396
1397    /// aws-global region with dualstack uses the regional endpoint
1398    #[test]
1399    fn test_52() {
1400        let params = crate::config::endpoint::Params::builder()
1401            .region("aws-global".to_string())
1402            .use_fips(false)
1403            .use_dual_stack(true)
1404            .accelerate(false)
1405            .build()
1406            .expect("invalid params");
1407        let resolver = crate::config::endpoint::DefaultResolver::new();
1408        let endpoint = resolver.resolve_endpoint(&params);
1409        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com");
1410        assert_eq!(
1411            endpoint,
1412            ::aws_smithy_types::endpoint::Endpoint::builder()
1413                .url("https://s3.dualstack.us-east-1.amazonaws.com")
1414                .property(
1415                    "authSchemes",
1416                    vec![::aws_smithy_types::Document::from({
1417                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1418                        out.insert("name".to_string(), "sigv4".to_string().into());
1419                        out.insert("signingName".to_string(), "s3".to_string().into());
1420                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1421                        out.insert("disableDoubleEncoding".to_string(), true.into());
1422                        out
1423                    })]
1424                )
1425                .build()
1426        );
1427    }
1428
1429    /// aws-global region with fips and dualstack uses the regional endpoint
1430    #[test]
1431    fn test_53() {
1432        let params = crate::config::endpoint::Params::builder()
1433            .region("aws-global".to_string())
1434            .use_fips(true)
1435            .use_dual_stack(true)
1436            .accelerate(false)
1437            .build()
1438            .expect("invalid params");
1439        let resolver = crate::config::endpoint::DefaultResolver::new();
1440        let endpoint = resolver.resolve_endpoint(&params);
1441        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com");
1442        assert_eq!(
1443            endpoint,
1444            ::aws_smithy_types::endpoint::Endpoint::builder()
1445                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com")
1446                .property(
1447                    "authSchemes",
1448                    vec![::aws_smithy_types::Document::from({
1449                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1450                        out.insert("name".to_string(), "sigv4".to_string().into());
1451                        out.insert("signingName".to_string(), "s3".to_string().into());
1452                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1453                        out.insert("disableDoubleEncoding".to_string(), true.into());
1454                        out
1455                    })]
1456                )
1457                .build()
1458        );
1459    }
1460
1461    /// aws-global region with accelerate on non-bucket case, uses global endpoint and ignores accelerate
1462    #[test]
1463    fn test_54() {
1464        let params = crate::config::endpoint::Params::builder()
1465            .region("aws-global".to_string())
1466            .use_fips(false)
1467            .use_dual_stack(false)
1468            .accelerate(true)
1469            .build()
1470            .expect("invalid params");
1471        let resolver = crate::config::endpoint::DefaultResolver::new();
1472        let endpoint = resolver.resolve_endpoint(&params);
1473        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1474        assert_eq!(
1475            endpoint,
1476            ::aws_smithy_types::endpoint::Endpoint::builder()
1477                .url("https://s3.amazonaws.com")
1478                .property(
1479                    "authSchemes",
1480                    vec![::aws_smithy_types::Document::from({
1481                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1482                        out.insert("name".to_string(), "sigv4".to_string().into());
1483                        out.insert("signingName".to_string(), "s3".to_string().into());
1484                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1485                        out.insert("disableDoubleEncoding".to_string(), true.into());
1486                        out
1487                    })]
1488                )
1489                .build()
1490        );
1491    }
1492
1493    /// aws-global region with custom endpoint, uses custom
1494    #[test]
1495    fn test_55() {
1496        let params = crate::config::endpoint::Params::builder()
1497            .region("aws-global".to_string())
1498            .endpoint("https://example.com".to_string())
1499            .use_global_endpoint(false)
1500            .use_fips(false)
1501            .use_dual_stack(false)
1502            .accelerate(false)
1503            .build()
1504            .expect("invalid params");
1505        let resolver = crate::config::endpoint::DefaultResolver::new();
1506        let endpoint = resolver.resolve_endpoint(&params);
1507        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1508        assert_eq!(
1509            endpoint,
1510            ::aws_smithy_types::endpoint::Endpoint::builder()
1511                .url("https://example.com")
1512                .property(
1513                    "authSchemes",
1514                    vec![::aws_smithy_types::Document::from({
1515                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1516                        out.insert("name".to_string(), "sigv4".to_string().into());
1517                        out.insert("signingName".to_string(), "s3".to_string().into());
1518                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1519                        out.insert("disableDoubleEncoding".to_string(), true.into());
1520                        out
1521                    })]
1522                )
1523                .build()
1524        );
1525    }
1526
1527    /// virtual addressing, aws-global region uses the global endpoint
1528    #[test]
1529    fn test_56() {
1530        let params = crate::config::endpoint::Params::builder()
1531            .region("aws-global".to_string())
1532            .bucket("bucket-name".to_string())
1533            .use_fips(false)
1534            .use_dual_stack(false)
1535            .accelerate(false)
1536            .build()
1537            .expect("invalid params");
1538        let resolver = crate::config::endpoint::DefaultResolver::new();
1539        let endpoint = resolver.resolve_endpoint(&params);
1540        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1541        assert_eq!(
1542            endpoint,
1543            ::aws_smithy_types::endpoint::Endpoint::builder()
1544                .url("https://bucket-name.s3.amazonaws.com")
1545                .property(
1546                    "authSchemes",
1547                    vec![::aws_smithy_types::Document::from({
1548                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1549                        out.insert("name".to_string(), "sigv4".to_string().into());
1550                        out.insert("signingName".to_string(), "s3".to_string().into());
1551                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1552                        out.insert("disableDoubleEncoding".to_string(), true.into());
1553                        out
1554                    })]
1555                )
1556                .build()
1557        );
1558    }
1559
1560    /// virtual addressing, aws-global region with Prefix, and Key uses the global endpoint. Prefix and Key parameters should not be used in endpoint evaluation.
1561    #[test]
1562    fn test_57() {
1563        let params = crate::config::endpoint::Params::builder()
1564            .region("aws-global".to_string())
1565            .bucket("bucket-name".to_string())
1566            .use_fips(false)
1567            .use_dual_stack(false)
1568            .accelerate(false)
1569            .prefix("prefix".to_string())
1570            .key("key".to_string())
1571            .build()
1572            .expect("invalid params");
1573        let resolver = crate::config::endpoint::DefaultResolver::new();
1574        let endpoint = resolver.resolve_endpoint(&params);
1575        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1576        assert_eq!(
1577            endpoint,
1578            ::aws_smithy_types::endpoint::Endpoint::builder()
1579                .url("https://bucket-name.s3.amazonaws.com")
1580                .property(
1581                    "authSchemes",
1582                    vec![::aws_smithy_types::Document::from({
1583                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1584                        out.insert("name".to_string(), "sigv4".to_string().into());
1585                        out.insert("signingName".to_string(), "s3".to_string().into());
1586                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1587                        out.insert("disableDoubleEncoding".to_string(), true.into());
1588                        out
1589                    })]
1590                )
1591                .build()
1592        );
1593    }
1594
1595    /// virtual addressing, aws-global region with fips uses the regional fips endpoint
1596    #[test]
1597    fn test_58() {
1598        let params = crate::config::endpoint::Params::builder()
1599            .region("aws-global".to_string())
1600            .bucket("bucket-name".to_string())
1601            .use_fips(true)
1602            .use_dual_stack(false)
1603            .accelerate(false)
1604            .build()
1605            .expect("invalid params");
1606        let resolver = crate::config::endpoint::DefaultResolver::new();
1607        let endpoint = resolver.resolve_endpoint(&params);
1608        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-east-1.amazonaws.com");
1609        assert_eq!(
1610            endpoint,
1611            ::aws_smithy_types::endpoint::Endpoint::builder()
1612                .url("https://bucket-name.s3-fips.us-east-1.amazonaws.com")
1613                .property(
1614                    "authSchemes",
1615                    vec![::aws_smithy_types::Document::from({
1616                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1617                        out.insert("name".to_string(), "sigv4".to_string().into());
1618                        out.insert("signingName".to_string(), "s3".to_string().into());
1619                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1620                        out.insert("disableDoubleEncoding".to_string(), true.into());
1621                        out
1622                    })]
1623                )
1624                .build()
1625        );
1626    }
1627
1628    /// virtual addressing, aws-global region with dualstack uses the regional dualstack endpoint
1629    #[test]
1630    fn test_59() {
1631        let params = crate::config::endpoint::Params::builder()
1632            .region("aws-global".to_string())
1633            .bucket("bucket-name".to_string())
1634            .use_fips(false)
1635            .use_dual_stack(true)
1636            .accelerate(false)
1637            .build()
1638            .expect("invalid params");
1639        let resolver = crate::config::endpoint::DefaultResolver::new();
1640        let endpoint = resolver.resolve_endpoint(&params);
1641        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-east-1.amazonaws.com");
1642        assert_eq!(
1643            endpoint,
1644            ::aws_smithy_types::endpoint::Endpoint::builder()
1645                .url("https://bucket-name.s3.dualstack.us-east-1.amazonaws.com")
1646                .property(
1647                    "authSchemes",
1648                    vec![::aws_smithy_types::Document::from({
1649                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1650                        out.insert("name".to_string(), "sigv4".to_string().into());
1651                        out.insert("signingName".to_string(), "s3".to_string().into());
1652                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1653                        out.insert("disableDoubleEncoding".to_string(), true.into());
1654                        out
1655                    })]
1656                )
1657                .build()
1658        );
1659    }
1660
1661    /// virtual addressing, aws-global region with fips/dualstack uses the regional fips/dualstack endpoint
1662    #[test]
1663    fn test_60() {
1664        let params = crate::config::endpoint::Params::builder()
1665            .region("aws-global".to_string())
1666            .bucket("bucket-name".to_string())
1667            .use_fips(true)
1668            .use_dual_stack(true)
1669            .accelerate(false)
1670            .build()
1671            .expect("invalid params");
1672        let resolver = crate::config::endpoint::DefaultResolver::new();
1673        let endpoint = resolver.resolve_endpoint(&params);
1674        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.us-east-1.amazonaws.com");
1675        assert_eq!(
1676            endpoint,
1677            ::aws_smithy_types::endpoint::Endpoint::builder()
1678                .url("https://bucket-name.s3-fips.dualstack.us-east-1.amazonaws.com")
1679                .property(
1680                    "authSchemes",
1681                    vec![::aws_smithy_types::Document::from({
1682                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1683                        out.insert("name".to_string(), "sigv4".to_string().into());
1684                        out.insert("signingName".to_string(), "s3".to_string().into());
1685                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1686                        out.insert("disableDoubleEncoding".to_string(), true.into());
1687                        out
1688                    })]
1689                )
1690                .build()
1691        );
1692    }
1693
1694    /// virtual addressing, aws-global region with accelerate uses the global accelerate endpoint
1695    #[test]
1696    fn test_61() {
1697        let params = crate::config::endpoint::Params::builder()
1698            .region("aws-global".to_string())
1699            .bucket("bucket-name".to_string())
1700            .use_fips(false)
1701            .use_dual_stack(false)
1702            .accelerate(true)
1703            .build()
1704            .expect("invalid params");
1705        let resolver = crate::config::endpoint::DefaultResolver::new();
1706        let endpoint = resolver.resolve_endpoint(&params);
1707        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
1708        assert_eq!(
1709            endpoint,
1710            ::aws_smithy_types::endpoint::Endpoint::builder()
1711                .url("https://bucket-name.s3-accelerate.amazonaws.com")
1712                .property(
1713                    "authSchemes",
1714                    vec![::aws_smithy_types::Document::from({
1715                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1716                        out.insert("name".to_string(), "sigv4".to_string().into());
1717                        out.insert("signingName".to_string(), "s3".to_string().into());
1718                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1719                        out.insert("disableDoubleEncoding".to_string(), true.into());
1720                        out
1721                    })]
1722                )
1723                .build()
1724        );
1725    }
1726
1727    /// virtual addressing, aws-global region with custom endpoint
1728    #[test]
1729    fn test_62() {
1730        let params = crate::config::endpoint::Params::builder()
1731            .region("aws-global".to_string())
1732            .endpoint("https://example.com".to_string())
1733            .bucket("bucket-name".to_string())
1734            .use_fips(false)
1735            .use_dual_stack(false)
1736            .accelerate(false)
1737            .build()
1738            .expect("invalid params");
1739        let resolver = crate::config::endpoint::DefaultResolver::new();
1740        let endpoint = resolver.resolve_endpoint(&params);
1741        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.example.com");
1742        assert_eq!(
1743            endpoint,
1744            ::aws_smithy_types::endpoint::Endpoint::builder()
1745                .url("https://bucket-name.example.com")
1746                .property(
1747                    "authSchemes",
1748                    vec![::aws_smithy_types::Document::from({
1749                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1750                        out.insert("name".to_string(), "sigv4".to_string().into());
1751                        out.insert("signingName".to_string(), "s3".to_string().into());
1752                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1753                        out.insert("disableDoubleEncoding".to_string(), true.into());
1754                        out
1755                    })]
1756                )
1757                .build()
1758        );
1759    }
1760
1761    /// virtual addressing, UseGlobalEndpoint and us-east-1 region uses the global endpoint
1762    #[test]
1763    fn test_63() {
1764        let params = crate::config::endpoint::Params::builder()
1765            .region("us-east-1".to_string())
1766            .use_global_endpoint(true)
1767            .bucket("bucket-name".to_string())
1768            .use_fips(false)
1769            .use_dual_stack(false)
1770            .accelerate(false)
1771            .build()
1772            .expect("invalid params");
1773        let resolver = crate::config::endpoint::DefaultResolver::new();
1774        let endpoint = resolver.resolve_endpoint(&params);
1775        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1776        assert_eq!(
1777            endpoint,
1778            ::aws_smithy_types::endpoint::Endpoint::builder()
1779                .url("https://bucket-name.s3.amazonaws.com")
1780                .property(
1781                    "authSchemes",
1782                    vec![::aws_smithy_types::Document::from({
1783                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1784                        out.insert("name".to_string(), "sigv4".to_string().into());
1785                        out.insert("signingName".to_string(), "s3".to_string().into());
1786                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1787                        out.insert("disableDoubleEncoding".to_string(), true.into());
1788                        out
1789                    })]
1790                )
1791                .build()
1792        );
1793    }
1794
1795    /// virtual addressing, UseGlobalEndpoint and us-west-2 region uses the regional endpoint
1796    #[test]
1797    fn test_64() {
1798        let params = crate::config::endpoint::Params::builder()
1799            .region("us-west-2".to_string())
1800            .use_global_endpoint(true)
1801            .bucket("bucket-name".to_string())
1802            .use_fips(false)
1803            .use_dual_stack(false)
1804            .accelerate(false)
1805            .build()
1806            .expect("invalid params");
1807        let resolver = crate::config::endpoint::DefaultResolver::new();
1808        let endpoint = resolver.resolve_endpoint(&params);
1809        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.us-west-2.amazonaws.com");
1810        assert_eq!(
1811            endpoint,
1812            ::aws_smithy_types::endpoint::Endpoint::builder()
1813                .url("https://bucket-name.s3.us-west-2.amazonaws.com")
1814                .property(
1815                    "authSchemes",
1816                    vec![::aws_smithy_types::Document::from({
1817                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1818                        out.insert("name".to_string(), "sigv4".to_string().into());
1819                        out.insert("signingName".to_string(), "s3".to_string().into());
1820                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
1821                        out.insert("disableDoubleEncoding".to_string(), true.into());
1822                        out
1823                    })]
1824                )
1825                .build()
1826        );
1827    }
1828
1829    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and fips uses the regional fips endpoint
1830    #[test]
1831    fn test_65() {
1832        let params = crate::config::endpoint::Params::builder()
1833            .region("us-east-1".to_string())
1834            .use_global_endpoint(true)
1835            .bucket("bucket-name".to_string())
1836            .use_fips(true)
1837            .use_dual_stack(false)
1838            .accelerate(false)
1839            .build()
1840            .expect("invalid params");
1841        let resolver = crate::config::endpoint::DefaultResolver::new();
1842        let endpoint = resolver.resolve_endpoint(&params);
1843        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-east-1.amazonaws.com");
1844        assert_eq!(
1845            endpoint,
1846            ::aws_smithy_types::endpoint::Endpoint::builder()
1847                .url("https://bucket-name.s3-fips.us-east-1.amazonaws.com")
1848                .property(
1849                    "authSchemes",
1850                    vec![::aws_smithy_types::Document::from({
1851                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1852                        out.insert("name".to_string(), "sigv4".to_string().into());
1853                        out.insert("signingName".to_string(), "s3".to_string().into());
1854                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1855                        out.insert("disableDoubleEncoding".to_string(), true.into());
1856                        out
1857                    })]
1858                )
1859                .build()
1860        );
1861    }
1862
1863    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and dualstack uses the regional dualstack endpoint
1864    #[test]
1865    fn test_66() {
1866        let params = crate::config::endpoint::Params::builder()
1867            .region("us-east-1".to_string())
1868            .use_global_endpoint(true)
1869            .bucket("bucket-name".to_string())
1870            .use_fips(false)
1871            .use_dual_stack(true)
1872            .accelerate(false)
1873            .build()
1874            .expect("invalid params");
1875        let resolver = crate::config::endpoint::DefaultResolver::new();
1876        let endpoint = resolver.resolve_endpoint(&params);
1877        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-east-1.amazonaws.com");
1878        assert_eq!(
1879            endpoint,
1880            ::aws_smithy_types::endpoint::Endpoint::builder()
1881                .url("https://bucket-name.s3.dualstack.us-east-1.amazonaws.com")
1882                .property(
1883                    "authSchemes",
1884                    vec![::aws_smithy_types::Document::from({
1885                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1886                        out.insert("name".to_string(), "sigv4".to_string().into());
1887                        out.insert("signingName".to_string(), "s3".to_string().into());
1888                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1889                        out.insert("disableDoubleEncoding".to_string(), true.into());
1890                        out
1891                    })]
1892                )
1893                .build()
1894        );
1895    }
1896
1897    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and accelerate uses the global accelerate endpoint
1898    #[test]
1899    fn test_67() {
1900        let params = crate::config::endpoint::Params::builder()
1901            .region("us-east-1".to_string())
1902            .use_global_endpoint(true)
1903            .bucket("bucket-name".to_string())
1904            .use_fips(false)
1905            .use_dual_stack(false)
1906            .accelerate(true)
1907            .build()
1908            .expect("invalid params");
1909        let resolver = crate::config::endpoint::DefaultResolver::new();
1910        let endpoint = resolver.resolve_endpoint(&params);
1911        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
1912        assert_eq!(
1913            endpoint,
1914            ::aws_smithy_types::endpoint::Endpoint::builder()
1915                .url("https://bucket-name.s3-accelerate.amazonaws.com")
1916                .property(
1917                    "authSchemes",
1918                    vec![::aws_smithy_types::Document::from({
1919                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1920                        out.insert("name".to_string(), "sigv4".to_string().into());
1921                        out.insert("signingName".to_string(), "s3".to_string().into());
1922                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1923                        out.insert("disableDoubleEncoding".to_string(), true.into());
1924                        out
1925                    })]
1926                )
1927                .build()
1928        );
1929    }
1930
1931    /// virtual addressing, UseGlobalEndpoint and us-east-1 region with custom endpoint
1932    #[test]
1933    fn test_68() {
1934        let params = crate::config::endpoint::Params::builder()
1935            .region("us-east-1".to_string())
1936            .endpoint("https://example.com".to_string())
1937            .use_global_endpoint(true)
1938            .bucket("bucket-name".to_string())
1939            .use_fips(false)
1940            .use_dual_stack(false)
1941            .accelerate(false)
1942            .build()
1943            .expect("invalid params");
1944        let resolver = crate::config::endpoint::DefaultResolver::new();
1945        let endpoint = resolver.resolve_endpoint(&params);
1946        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.example.com");
1947        assert_eq!(
1948            endpoint,
1949            ::aws_smithy_types::endpoint::Endpoint::builder()
1950                .url("https://bucket-name.example.com")
1951                .property(
1952                    "authSchemes",
1953                    vec![::aws_smithy_types::Document::from({
1954                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1955                        out.insert("name".to_string(), "sigv4".to_string().into());
1956                        out.insert("signingName".to_string(), "s3".to_string().into());
1957                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1958                        out.insert("disableDoubleEncoding".to_string(), true.into());
1959                        out
1960                    })]
1961                )
1962                .build()
1963        );
1964    }
1965
1966    /// ForcePathStyle, aws-global region uses the global endpoint
1967    #[test]
1968    fn test_69() {
1969        let params = crate::config::endpoint::Params::builder()
1970            .region("aws-global".to_string())
1971            .bucket("bucket-name".to_string())
1972            .force_path_style(true)
1973            .use_fips(false)
1974            .use_dual_stack(false)
1975            .accelerate(false)
1976            .build()
1977            .expect("invalid params");
1978        let resolver = crate::config::endpoint::DefaultResolver::new();
1979        let endpoint = resolver.resolve_endpoint(&params);
1980        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket-name");
1981        assert_eq!(
1982            endpoint,
1983            ::aws_smithy_types::endpoint::Endpoint::builder()
1984                .url("https://s3.amazonaws.com/bucket-name")
1985                .property(
1986                    "authSchemes",
1987                    vec![::aws_smithy_types::Document::from({
1988                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1989                        out.insert("name".to_string(), "sigv4".to_string().into());
1990                        out.insert("signingName".to_string(), "s3".to_string().into());
1991                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1992                        out.insert("disableDoubleEncoding".to_string(), true.into());
1993                        out
1994                    })]
1995                )
1996                .build()
1997        );
1998    }
1999
2000    /// ForcePathStyle, aws-global region with fips is invalid
2001    #[test]
2002    fn test_70() {
2003        let params = crate::config::endpoint::Params::builder()
2004            .region("aws-global".to_string())
2005            .bucket("bucket-name".to_string())
2006            .force_path_style(true)
2007            .use_fips(true)
2008            .use_dual_stack(false)
2009            .accelerate(false)
2010            .build()
2011            .expect("invalid params");
2012        let resolver = crate::config::endpoint::DefaultResolver::new();
2013        let endpoint = resolver.resolve_endpoint(&params);
2014        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket-name");
2015        assert_eq!(
2016            endpoint,
2017            ::aws_smithy_types::endpoint::Endpoint::builder()
2018                .url("https://s3-fips.us-east-1.amazonaws.com/bucket-name")
2019                .property(
2020                    "authSchemes",
2021                    vec![::aws_smithy_types::Document::from({
2022                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2023                        out.insert("signingName".to_string(), "s3".to_string().into());
2024                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2025                        out.insert("disableDoubleEncoding".to_string(), true.into());
2026                        out.insert("name".to_string(), "sigv4".to_string().into());
2027                        out
2028                    })]
2029                )
2030                .build()
2031        );
2032    }
2033
2034    /// ForcePathStyle, aws-global region with dualstack uses regional dualstack endpoint
2035    #[test]
2036    fn test_71() {
2037        let params = crate::config::endpoint::Params::builder()
2038            .region("aws-global".to_string())
2039            .bucket("bucket-name".to_string())
2040            .force_path_style(true)
2041            .use_fips(false)
2042            .use_dual_stack(true)
2043            .accelerate(false)
2044            .build()
2045            .expect("invalid params");
2046        let resolver = crate::config::endpoint::DefaultResolver::new();
2047        let endpoint = resolver.resolve_endpoint(&params);
2048        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket-name");
2049        assert_eq!(
2050            endpoint,
2051            ::aws_smithy_types::endpoint::Endpoint::builder()
2052                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket-name")
2053                .property(
2054                    "authSchemes",
2055                    vec![::aws_smithy_types::Document::from({
2056                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2057                        out.insert("name".to_string(), "sigv4".to_string().into());
2058                        out.insert("signingName".to_string(), "s3".to_string().into());
2059                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2060                        out.insert("disableDoubleEncoding".to_string(), true.into());
2061                        out
2062                    })]
2063                )
2064                .build()
2065        );
2066    }
2067
2068    /// ForcePathStyle, aws-global region custom endpoint uses the custom endpoint
2069    #[test]
2070    fn test_72() {
2071        let params = crate::config::endpoint::Params::builder()
2072            .region("aws-global".to_string())
2073            .endpoint("https://example.com".to_string())
2074            .bucket("bucket-name".to_string())
2075            .force_path_style(true)
2076            .use_fips(false)
2077            .use_dual_stack(false)
2078            .accelerate(false)
2079            .build()
2080            .expect("invalid params");
2081        let resolver = crate::config::endpoint::DefaultResolver::new();
2082        let endpoint = resolver.resolve_endpoint(&params);
2083        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com/bucket-name");
2084        assert_eq!(
2085            endpoint,
2086            ::aws_smithy_types::endpoint::Endpoint::builder()
2087                .url("https://example.com/bucket-name")
2088                .property(
2089                    "authSchemes",
2090                    vec![::aws_smithy_types::Document::from({
2091                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2092                        out.insert("name".to_string(), "sigv4".to_string().into());
2093                        out.insert("signingName".to_string(), "s3".to_string().into());
2094                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2095                        out.insert("disableDoubleEncoding".to_string(), true.into());
2096                        out
2097                    })]
2098                )
2099                .build()
2100        );
2101    }
2102
2103    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region uses the global endpoint
2104    #[test]
2105    fn test_73() {
2106        let params = crate::config::endpoint::Params::builder()
2107            .region("us-east-1".to_string())
2108            .bucket("bucket-name".to_string())
2109            .use_global_endpoint(true)
2110            .force_path_style(true)
2111            .use_fips(false)
2112            .use_dual_stack(false)
2113            .accelerate(false)
2114            .build()
2115            .expect("invalid params");
2116        let resolver = crate::config::endpoint::DefaultResolver::new();
2117        let endpoint = resolver.resolve_endpoint(&params);
2118        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket-name");
2119        assert_eq!(
2120            endpoint,
2121            ::aws_smithy_types::endpoint::Endpoint::builder()
2122                .url("https://s3.amazonaws.com/bucket-name")
2123                .property(
2124                    "authSchemes",
2125                    vec![::aws_smithy_types::Document::from({
2126                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2127                        out.insert("name".to_string(), "sigv4".to_string().into());
2128                        out.insert("signingName".to_string(), "s3".to_string().into());
2129                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2130                        out.insert("disableDoubleEncoding".to_string(), true.into());
2131                        out
2132                    })]
2133                )
2134                .build()
2135        );
2136    }
2137
2138    /// ForcePathStyle, UseGlobalEndpoint us-west-2 region uses the regional endpoint
2139    #[test]
2140    fn test_74() {
2141        let params = crate::config::endpoint::Params::builder()
2142            .region("us-west-2".to_string())
2143            .bucket("bucket-name".to_string())
2144            .use_global_endpoint(true)
2145            .force_path_style(true)
2146            .use_fips(false)
2147            .use_dual_stack(false)
2148            .accelerate(false)
2149            .build()
2150            .expect("invalid params");
2151        let resolver = crate::config::endpoint::DefaultResolver::new();
2152        let endpoint = resolver.resolve_endpoint(&params);
2153        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket-name");
2154        assert_eq!(
2155            endpoint,
2156            ::aws_smithy_types::endpoint::Endpoint::builder()
2157                .url("https://s3.us-west-2.amazonaws.com/bucket-name")
2158                .property(
2159                    "authSchemes",
2160                    vec![::aws_smithy_types::Document::from({
2161                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2162                        out.insert("name".to_string(), "sigv4".to_string().into());
2163                        out.insert("signingName".to_string(), "s3".to_string().into());
2164                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2165                        out.insert("disableDoubleEncoding".to_string(), true.into());
2166                        out
2167                    })]
2168                )
2169                .build()
2170        );
2171    }
2172
2173    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region, dualstack uses the regional dualstack endpoint
2174    #[test]
2175    fn test_75() {
2176        let params = crate::config::endpoint::Params::builder()
2177            .region("us-east-1".to_string())
2178            .bucket("bucket-name".to_string())
2179            .use_global_endpoint(true)
2180            .force_path_style(true)
2181            .use_fips(false)
2182            .use_dual_stack(true)
2183            .accelerate(false)
2184            .build()
2185            .expect("invalid params");
2186        let resolver = crate::config::endpoint::DefaultResolver::new();
2187        let endpoint = resolver.resolve_endpoint(&params);
2188        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket-name");
2189        assert_eq!(
2190            endpoint,
2191            ::aws_smithy_types::endpoint::Endpoint::builder()
2192                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket-name")
2193                .property(
2194                    "authSchemes",
2195                    vec![::aws_smithy_types::Document::from({
2196                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2197                        out.insert("name".to_string(), "sigv4".to_string().into());
2198                        out.insert("signingName".to_string(), "s3".to_string().into());
2199                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2200                        out.insert("disableDoubleEncoding".to_string(), true.into());
2201                        out
2202                    })]
2203                )
2204                .build()
2205        );
2206    }
2207
2208    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region custom endpoint uses the custom endpoint
2209    #[test]
2210    fn test_76() {
2211        let params = crate::config::endpoint::Params::builder()
2212            .region("us-east-1".to_string())
2213            .bucket("bucket-name".to_string())
2214            .endpoint("https://example.com".to_string())
2215            .use_global_endpoint(true)
2216            .force_path_style(true)
2217            .use_fips(false)
2218            .use_dual_stack(false)
2219            .accelerate(false)
2220            .build()
2221            .expect("invalid params");
2222        let resolver = crate::config::endpoint::DefaultResolver::new();
2223        let endpoint = resolver.resolve_endpoint(&params);
2224        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com/bucket-name");
2225        assert_eq!(
2226            endpoint,
2227            ::aws_smithy_types::endpoint::Endpoint::builder()
2228                .url("https://example.com/bucket-name")
2229                .property(
2230                    "authSchemes",
2231                    vec![::aws_smithy_types::Document::from({
2232                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2233                        out.insert("name".to_string(), "sigv4".to_string().into());
2234                        out.insert("signingName".to_string(), "s3".to_string().into());
2235                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2236                        out.insert("disableDoubleEncoding".to_string(), true.into());
2237                        out
2238                    })]
2239                )
2240                .build()
2241        );
2242    }
2243
2244    /// ARN with aws-global region and  UseArnRegion uses the regional endpoint
2245    #[test]
2246    fn test_77() {
2247        let params = crate::config::endpoint::Params::builder()
2248            .region("aws-global".to_string())
2249            .use_arn_region(true)
2250            .use_fips(false)
2251            .use_dual_stack(false)
2252            .accelerate(false)
2253            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
2254            .build()
2255            .expect("invalid params");
2256        let resolver = crate::config::endpoint::DefaultResolver::new();
2257        let endpoint = resolver.resolve_endpoint(&params);
2258        let endpoint =
2259            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
2260        assert_eq!(
2261            endpoint,
2262            ::aws_smithy_types::endpoint::Endpoint::builder()
2263                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
2264                .property(
2265                    "authSchemes",
2266                    vec![
2267                        ::aws_smithy_types::Document::from({
2268                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2269                            out.insert("name".to_string(), "sigv4a".to_string().into());
2270                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
2271                            out.insert(
2272                                "signingRegionSet".to_string(),
2273                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
2274                            );
2275                            out.insert("disableDoubleEncoding".to_string(), true.into());
2276                            out
2277                        }),
2278                        ::aws_smithy_types::Document::from({
2279                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2280                            out.insert("name".to_string(), "sigv4".to_string().into());
2281                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
2282                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2283                            out.insert("disableDoubleEncoding".to_string(), true.into());
2284                            out
2285                        })
2286                    ]
2287                )
2288                .build()
2289        );
2290    }
2291
2292    /// cross partition MRAP ARN is an error
2293    #[test]
2294    fn test_78() {
2295        let params = crate::config::endpoint::Params::builder()
2296            .bucket("arn:aws-cn:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
2297            .region("us-west-1".to_string())
2298            .build()
2299            .expect("invalid params");
2300        let resolver = crate::config::endpoint::DefaultResolver::new();
2301        let endpoint = resolver.resolve_endpoint(&params);
2302        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]");
2303        assert_eq!(
2304            format!("{}", error),
2305            "Client was configured for partition `aws` but bucket referred to partition `aws-cn`"
2306        )
2307    }
2308
2309    /// Endpoint override, accesspoint with HTTP, port
2310    #[test]
2311    fn test_79() {
2312        let params = crate::config::endpoint::Params::builder()
2313            .endpoint("http://beta.example.com:1234".to_string())
2314            .region("us-west-2".to_string())
2315            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
2316            .build()
2317            .expect("invalid params");
2318        let resolver = crate::config::endpoint::DefaultResolver::new();
2319        let endpoint = resolver.resolve_endpoint(&params);
2320        let endpoint = endpoint.expect("Expected valid endpoint: http://myendpoint-123456789012.beta.example.com:1234");
2321        assert_eq!(
2322            endpoint,
2323            ::aws_smithy_types::endpoint::Endpoint::builder()
2324                .url("http://myendpoint-123456789012.beta.example.com:1234")
2325                .property(
2326                    "authSchemes",
2327                    vec![::aws_smithy_types::Document::from({
2328                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2329                        out.insert("name".to_string(), "sigv4".to_string().into());
2330                        out.insert("signingName".to_string(), "s3".to_string().into());
2331                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2332                        out.insert("disableDoubleEncoding".to_string(), true.into());
2333                        out
2334                    })]
2335                )
2336                .build()
2337        );
2338    }
2339
2340    /// Endpoint override, accesspoint with http, path, query, and port
2341    #[test]
2342    fn test_80() {
2343        let params = crate::config::endpoint::Params::builder()
2344            .region("us-west-2".to_string())
2345            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
2346            .endpoint("http://beta.example.com:1234/path".to_string())
2347            .use_fips(false)
2348            .use_dual_stack(false)
2349            .accelerate(false)
2350            .build()
2351            .expect("invalid params");
2352        let resolver = crate::config::endpoint::DefaultResolver::new();
2353        let endpoint = resolver.resolve_endpoint(&params);
2354        let endpoint = endpoint.expect("Expected valid endpoint: http://myendpoint-123456789012.beta.example.com:1234/path");
2355        assert_eq!(
2356            endpoint,
2357            ::aws_smithy_types::endpoint::Endpoint::builder()
2358                .url("http://myendpoint-123456789012.beta.example.com:1234/path")
2359                .property(
2360                    "authSchemes",
2361                    vec![::aws_smithy_types::Document::from({
2362                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2363                        out.insert("name".to_string(), "sigv4".to_string().into());
2364                        out.insert("signingName".to_string(), "s3".to_string().into());
2365                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2366                        out.insert("disableDoubleEncoding".to_string(), true.into());
2367                        out
2368                    })]
2369                )
2370                .build()
2371        );
2372    }
2373
2374    /// non-bucket endpoint override with FIPS = error
2375    #[test]
2376    fn test_81() {
2377        let params = crate::config::endpoint::Params::builder()
2378            .region("us-west-2".to_string())
2379            .endpoint("http://beta.example.com:1234/path".to_string())
2380            .use_fips(true)
2381            .use_dual_stack(false)
2382            .build()
2383            .expect("invalid params");
2384        let resolver = crate::config::endpoint::DefaultResolver::new();
2385        let endpoint = resolver.resolve_endpoint(&params);
2386        let error =
2387            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [non-bucket endpoint override with FIPS = error]");
2388        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2389    }
2390
2391    /// FIPS + dualstack + custom endpoint
2392    #[test]
2393    fn test_82() {
2394        let params = crate::config::endpoint::Params::builder()
2395            .region("us-west-2".to_string())
2396            .endpoint("http://beta.example.com:1234/path".to_string())
2397            .use_fips(true)
2398            .use_dual_stack(true)
2399            .build()
2400            .expect("invalid params");
2401        let resolver = crate::config::endpoint::DefaultResolver::new();
2402        let endpoint = resolver.resolve_endpoint(&params);
2403        let error =
2404            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [FIPS + dualstack + custom endpoint]");
2405        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
2406    }
2407
2408    /// dualstack + custom endpoint
2409    #[test]
2410    fn test_83() {
2411        let params = crate::config::endpoint::Params::builder()
2412            .region("us-west-2".to_string())
2413            .endpoint("http://beta.example.com:1234/path".to_string())
2414            .use_fips(false)
2415            .use_dual_stack(true)
2416            .build()
2417            .expect("invalid params");
2418        let resolver = crate::config::endpoint::DefaultResolver::new();
2419        let endpoint = resolver.resolve_endpoint(&params);
2420        let error = endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [dualstack + custom endpoint]");
2421        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
2422    }
2423
2424    /// custom endpoint without FIPS/dualstack
2425    #[test]
2426    fn test_84() {
2427        let params = crate::config::endpoint::Params::builder()
2428            .region("us-west-2".to_string())
2429            .endpoint("http://beta.example.com:1234/path".to_string())
2430            .use_fips(false)
2431            .use_dual_stack(false)
2432            .build()
2433            .expect("invalid params");
2434        let resolver = crate::config::endpoint::DefaultResolver::new();
2435        let endpoint = resolver.resolve_endpoint(&params);
2436        let endpoint = endpoint.expect("Expected valid endpoint: http://beta.example.com:1234/path");
2437        assert_eq!(
2438            endpoint,
2439            ::aws_smithy_types::endpoint::Endpoint::builder()
2440                .url("http://beta.example.com:1234/path")
2441                .property(
2442                    "authSchemes",
2443                    vec![::aws_smithy_types::Document::from({
2444                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2445                        out.insert("name".to_string(), "sigv4".to_string().into());
2446                        out.insert("signingName".to_string(), "s3".to_string().into());
2447                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2448                        out.insert("disableDoubleEncoding".to_string(), true.into());
2449                        out
2450                    })]
2451                )
2452                .build()
2453        );
2454    }
2455
2456    /// s3 object lambda with access points disabled
2457    #[test]
2458    fn test_85() {
2459        let params = crate::config::endpoint::Params::builder()
2460            .region("us-west-2".to_string())
2461            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:myendpoint".to_string())
2462            .disable_access_points(true)
2463            .build()
2464            .expect("invalid params");
2465        let resolver = crate::config::endpoint::DefaultResolver::new();
2466        let endpoint = resolver.resolve_endpoint(&params);
2467        let error =
2468            endpoint.expect_err("expected error: Access points are not supported for this operation [s3 object lambda with access points disabled]");
2469        assert_eq!(format!("{}", error), "Access points are not supported for this operation")
2470    }
2471
2472    /// non bucket + FIPS
2473    #[test]
2474    fn test_86() {
2475        let params = crate::config::endpoint::Params::builder()
2476            .region("us-west-2".to_string())
2477            .use_fips(true)
2478            .use_dual_stack(false)
2479            .build()
2480            .expect("invalid params");
2481        let resolver = crate::config::endpoint::DefaultResolver::new();
2482        let endpoint = resolver.resolve_endpoint(&params);
2483        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-west-2.amazonaws.com");
2484        assert_eq!(
2485            endpoint,
2486            ::aws_smithy_types::endpoint::Endpoint::builder()
2487                .url("https://s3-fips.us-west-2.amazonaws.com")
2488                .property(
2489                    "authSchemes",
2490                    vec![::aws_smithy_types::Document::from({
2491                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2492                        out.insert("name".to_string(), "sigv4".to_string().into());
2493                        out.insert("signingName".to_string(), "s3".to_string().into());
2494                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2495                        out.insert("disableDoubleEncoding".to_string(), true.into());
2496                        out
2497                    })]
2498                )
2499                .build()
2500        );
2501    }
2502
2503    /// standard non bucket endpoint
2504    #[test]
2505    fn test_87() {
2506        let params = crate::config::endpoint::Params::builder()
2507            .region("us-west-2".to_string())
2508            .use_fips(false)
2509            .use_dual_stack(false)
2510            .build()
2511            .expect("invalid params");
2512        let resolver = crate::config::endpoint::DefaultResolver::new();
2513        let endpoint = resolver.resolve_endpoint(&params);
2514        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com");
2515        assert_eq!(
2516            endpoint,
2517            ::aws_smithy_types::endpoint::Endpoint::builder()
2518                .url("https://s3.us-west-2.amazonaws.com")
2519                .property(
2520                    "authSchemes",
2521                    vec![::aws_smithy_types::Document::from({
2522                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2523                        out.insert("name".to_string(), "sigv4".to_string().into());
2524                        out.insert("signingName".to_string(), "s3".to_string().into());
2525                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2526                        out.insert("disableDoubleEncoding".to_string(), true.into());
2527                        out
2528                    })]
2529                )
2530                .build()
2531        );
2532    }
2533
2534    /// non bucket endpoint with FIPS + Dualstack
2535    #[test]
2536    fn test_88() {
2537        let params = crate::config::endpoint::Params::builder()
2538            .region("us-west-2".to_string())
2539            .use_fips(true)
2540            .use_dual_stack(true)
2541            .build()
2542            .expect("invalid params");
2543        let resolver = crate::config::endpoint::DefaultResolver::new();
2544        let endpoint = resolver.resolve_endpoint(&params);
2545        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-west-2.amazonaws.com");
2546        assert_eq!(
2547            endpoint,
2548            ::aws_smithy_types::endpoint::Endpoint::builder()
2549                .url("https://s3-fips.dualstack.us-west-2.amazonaws.com")
2550                .property(
2551                    "authSchemes",
2552                    vec![::aws_smithy_types::Document::from({
2553                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2554                        out.insert("name".to_string(), "sigv4".to_string().into());
2555                        out.insert("signingName".to_string(), "s3".to_string().into());
2556                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2557                        out.insert("disableDoubleEncoding".to_string(), true.into());
2558                        out
2559                    })]
2560                )
2561                .build()
2562        );
2563    }
2564
2565    /// non bucket endpoint with dualstack
2566    #[test]
2567    fn test_89() {
2568        let params = crate::config::endpoint::Params::builder()
2569            .region("us-west-2".to_string())
2570            .use_fips(false)
2571            .use_dual_stack(true)
2572            .build()
2573            .expect("invalid params");
2574        let resolver = crate::config::endpoint::DefaultResolver::new();
2575        let endpoint = resolver.resolve_endpoint(&params);
2576        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com");
2577        assert_eq!(
2578            endpoint,
2579            ::aws_smithy_types::endpoint::Endpoint::builder()
2580                .url("https://s3.dualstack.us-west-2.amazonaws.com")
2581                .property(
2582                    "authSchemes",
2583                    vec![::aws_smithy_types::Document::from({
2584                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2585                        out.insert("name".to_string(), "sigv4".to_string().into());
2586                        out.insert("signingName".to_string(), "s3".to_string().into());
2587                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2588                        out.insert("disableDoubleEncoding".to_string(), true.into());
2589                        out
2590                    })]
2591                )
2592                .build()
2593        );
2594    }
2595
2596    /// use global endpoint + IP address endpoint override
2597    #[test]
2598    fn test_90() {
2599        let params = crate::config::endpoint::Params::builder()
2600            .region("us-east-1".to_string())
2601            .bucket("bucket".to_string())
2602            .use_fips(false)
2603            .use_dual_stack(false)
2604            .endpoint("http://127.0.0.1".to_string())
2605            .use_global_endpoint(true)
2606            .build()
2607            .expect("invalid params");
2608        let resolver = crate::config::endpoint::DefaultResolver::new();
2609        let endpoint = resolver.resolve_endpoint(&params);
2610        let endpoint = endpoint.expect("Expected valid endpoint: http://127.0.0.1/bucket");
2611        assert_eq!(
2612            endpoint,
2613            ::aws_smithy_types::endpoint::Endpoint::builder()
2614                .url("http://127.0.0.1/bucket")
2615                .property(
2616                    "authSchemes",
2617                    vec![::aws_smithy_types::Document::from({
2618                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2619                        out.insert("name".to_string(), "sigv4".to_string().into());
2620                        out.insert("signingName".to_string(), "s3".to_string().into());
2621                        out.insert("disableDoubleEncoding".to_string(), true.into());
2622                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2623                        out
2624                    })]
2625                )
2626                .build()
2627        );
2628    }
2629
2630    /// non-dns endpoint + global endpoint
2631    #[test]
2632    fn test_91() {
2633        let params = crate::config::endpoint::Params::builder()
2634            .region("us-east-1".to_string())
2635            .bucket("bucket!".to_string())
2636            .use_fips(false)
2637            .use_dual_stack(false)
2638            .use_global_endpoint(true)
2639            .build()
2640            .expect("invalid params");
2641        let resolver = crate::config::endpoint::DefaultResolver::new();
2642        let endpoint = resolver.resolve_endpoint(&params);
2643        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket%21");
2644        assert_eq!(
2645            endpoint,
2646            ::aws_smithy_types::endpoint::Endpoint::builder()
2647                .url("https://s3.amazonaws.com/bucket%21")
2648                .property(
2649                    "authSchemes",
2650                    vec![::aws_smithy_types::Document::from({
2651                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2652                        out.insert("name".to_string(), "sigv4".to_string().into());
2653                        out.insert("signingName".to_string(), "s3".to_string().into());
2654                        out.insert("disableDoubleEncoding".to_string(), true.into());
2655                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2656                        out
2657                    })]
2658                )
2659                .build()
2660        );
2661    }
2662
2663    /// endpoint override + use global endpoint
2664    #[test]
2665    fn test_92() {
2666        let params = crate::config::endpoint::Params::builder()
2667            .region("us-east-1".to_string())
2668            .bucket("bucket!".to_string())
2669            .use_fips(false)
2670            .use_dual_stack(false)
2671            .use_global_endpoint(true)
2672            .endpoint("http://foo.com".to_string())
2673            .build()
2674            .expect("invalid params");
2675        let resolver = crate::config::endpoint::DefaultResolver::new();
2676        let endpoint = resolver.resolve_endpoint(&params);
2677        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
2678        assert_eq!(
2679            endpoint,
2680            ::aws_smithy_types::endpoint::Endpoint::builder()
2681                .url("http://foo.com/bucket%21")
2682                .property(
2683                    "authSchemes",
2684                    vec![::aws_smithy_types::Document::from({
2685                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2686                        out.insert("name".to_string(), "sigv4".to_string().into());
2687                        out.insert("signingName".to_string(), "s3".to_string().into());
2688                        out.insert("disableDoubleEncoding".to_string(), true.into());
2689                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2690                        out
2691                    })]
2692                )
2693                .build()
2694        );
2695    }
2696
2697    /// FIPS + dualstack + non-bucket endpoint
2698    #[test]
2699    fn test_93() {
2700        let params = crate::config::endpoint::Params::builder()
2701            .region("us-east-1".to_string())
2702            .bucket("bucket!".to_string())
2703            .use_fips(true)
2704            .use_dual_stack(true)
2705            .build()
2706            .expect("invalid params");
2707        let resolver = crate::config::endpoint::DefaultResolver::new();
2708        let endpoint = resolver.resolve_endpoint(&params);
2709        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
2710        assert_eq!(
2711            endpoint,
2712            ::aws_smithy_types::endpoint::Endpoint::builder()
2713                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
2714                .property(
2715                    "authSchemes",
2716                    vec![::aws_smithy_types::Document::from({
2717                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2718                        out.insert("name".to_string(), "sigv4".to_string().into());
2719                        out.insert("signingName".to_string(), "s3".to_string().into());
2720                        out.insert("disableDoubleEncoding".to_string(), true.into());
2721                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2722                        out
2723                    })]
2724                )
2725                .build()
2726        );
2727    }
2728
2729    /// FIPS + dualstack + non-DNS endpoint
2730    #[test]
2731    fn test_94() {
2732        let params = crate::config::endpoint::Params::builder()
2733            .region("us-east-1".to_string())
2734            .bucket("bucket!".to_string())
2735            .force_path_style(true)
2736            .use_fips(true)
2737            .use_dual_stack(true)
2738            .build()
2739            .expect("invalid params");
2740        let resolver = crate::config::endpoint::DefaultResolver::new();
2741        let endpoint = resolver.resolve_endpoint(&params);
2742        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
2743        assert_eq!(
2744            endpoint,
2745            ::aws_smithy_types::endpoint::Endpoint::builder()
2746                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
2747                .property(
2748                    "authSchemes",
2749                    vec![::aws_smithy_types::Document::from({
2750                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2751                        out.insert("name".to_string(), "sigv4".to_string().into());
2752                        out.insert("signingName".to_string(), "s3".to_string().into());
2753                        out.insert("disableDoubleEncoding".to_string(), true.into());
2754                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2755                        out
2756                    })]
2757                )
2758                .build()
2759        );
2760    }
2761
2762    /// endpoint override + FIPS + dualstack (BUG)
2763    #[test]
2764    fn test_95() {
2765        let params = crate::config::endpoint::Params::builder()
2766            .region("us-east-1".to_string())
2767            .bucket("bucket!".to_string())
2768            .force_path_style(true)
2769            .use_fips(true)
2770            .use_dual_stack(false)
2771            .endpoint("http://foo.com".to_string())
2772            .build()
2773            .expect("invalid params");
2774        let resolver = crate::config::endpoint::DefaultResolver::new();
2775        let endpoint = resolver.resolve_endpoint(&params);
2776        let error =
2777            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [endpoint override + FIPS + dualstack (BUG)]");
2778        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2779    }
2780
2781    /// endpoint override + non-dns bucket + FIPS (BUG)
2782    #[test]
2783    fn test_96() {
2784        let params = crate::config::endpoint::Params::builder()
2785            .region("us-east-1".to_string())
2786            .bucket("bucket!".to_string())
2787            .use_fips(true)
2788            .use_dual_stack(false)
2789            .endpoint("http://foo.com".to_string())
2790            .build()
2791            .expect("invalid params");
2792        let resolver = crate::config::endpoint::DefaultResolver::new();
2793        let endpoint = resolver.resolve_endpoint(&params);
2794        let error =
2795            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [endpoint override + non-dns bucket + FIPS (BUG)]");
2796        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2797    }
2798
2799    /// FIPS + bucket endpoint + force path style
2800    #[test]
2801    fn test_97() {
2802        let params = crate::config::endpoint::Params::builder()
2803            .region("us-east-1".to_string())
2804            .bucket("bucket!".to_string())
2805            .force_path_style(true)
2806            .use_fips(true)
2807            .use_dual_stack(false)
2808            .use_global_endpoint(true)
2809            .build()
2810            .expect("invalid params");
2811        let resolver = crate::config::endpoint::DefaultResolver::new();
2812        let endpoint = resolver.resolve_endpoint(&params);
2813        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
2814        assert_eq!(
2815            endpoint,
2816            ::aws_smithy_types::endpoint::Endpoint::builder()
2817                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
2818                .property(
2819                    "authSchemes",
2820                    vec![::aws_smithy_types::Document::from({
2821                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2822                        out.insert("name".to_string(), "sigv4".to_string().into());
2823                        out.insert("signingName".to_string(), "s3".to_string().into());
2824                        out.insert("disableDoubleEncoding".to_string(), true.into());
2825                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2826                        out
2827                    })]
2828                )
2829                .build()
2830        );
2831    }
2832
2833    /// bucket + FIPS + force path style
2834    #[test]
2835    fn test_98() {
2836        let params = crate::config::endpoint::Params::builder()
2837            .region("us-east-1".to_string())
2838            .bucket("bucket".to_string())
2839            .force_path_style(true)
2840            .use_fips(true)
2841            .use_dual_stack(true)
2842            .use_global_endpoint(true)
2843            .build()
2844            .expect("invalid params");
2845        let resolver = crate::config::endpoint::DefaultResolver::new();
2846        let endpoint = resolver.resolve_endpoint(&params);
2847        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket");
2848        assert_eq!(
2849            endpoint,
2850            ::aws_smithy_types::endpoint::Endpoint::builder()
2851                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket")
2852                .property(
2853                    "authSchemes",
2854                    vec![::aws_smithy_types::Document::from({
2855                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2856                        out.insert("name".to_string(), "sigv4".to_string().into());
2857                        out.insert("signingName".to_string(), "s3".to_string().into());
2858                        out.insert("disableDoubleEncoding".to_string(), true.into());
2859                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2860                        out
2861                    })]
2862                )
2863                .build()
2864        );
2865    }
2866
2867    /// FIPS + dualstack + use global endpoint
2868    #[test]
2869    fn test_99() {
2870        let params = crate::config::endpoint::Params::builder()
2871            .region("us-east-1".to_string())
2872            .bucket("bucket".to_string())
2873            .use_fips(true)
2874            .use_dual_stack(true)
2875            .use_global_endpoint(true)
2876            .build()
2877            .expect("invalid params");
2878        let resolver = crate::config::endpoint::DefaultResolver::new();
2879        let endpoint = resolver.resolve_endpoint(&params);
2880        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-fips.dualstack.us-east-1.amazonaws.com");
2881        assert_eq!(
2882            endpoint,
2883            ::aws_smithy_types::endpoint::Endpoint::builder()
2884                .url("https://bucket.s3-fips.dualstack.us-east-1.amazonaws.com")
2885                .property(
2886                    "authSchemes",
2887                    vec![::aws_smithy_types::Document::from({
2888                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2889                        out.insert("name".to_string(), "sigv4".to_string().into());
2890                        out.insert("signingName".to_string(), "s3".to_string().into());
2891                        out.insert("disableDoubleEncoding".to_string(), true.into());
2892                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2893                        out
2894                    })]
2895                )
2896                .build()
2897        );
2898    }
2899
2900    /// URI encoded bucket + use global endpoint
2901    #[test]
2902    fn test_100() {
2903        let params = crate::config::endpoint::Params::builder()
2904            .region("us-east-1".to_string())
2905            .bucket("bucket!".to_string())
2906            .use_fips(true)
2907            .use_dual_stack(false)
2908            .use_global_endpoint(true)
2909            .endpoint("https://foo.com".to_string())
2910            .build()
2911            .expect("invalid params");
2912        let resolver = crate::config::endpoint::DefaultResolver::new();
2913        let endpoint = resolver.resolve_endpoint(&params);
2914        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [URI encoded bucket + use global endpoint]");
2915        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2916    }
2917
2918    /// FIPS + path based endpoint
2919    #[test]
2920    fn test_101() {
2921        let params = crate::config::endpoint::Params::builder()
2922            .region("us-east-1".to_string())
2923            .bucket("bucket!".to_string())
2924            .use_fips(true)
2925            .use_dual_stack(false)
2926            .accelerate(false)
2927            .use_global_endpoint(true)
2928            .build()
2929            .expect("invalid params");
2930        let resolver = crate::config::endpoint::DefaultResolver::new();
2931        let endpoint = resolver.resolve_endpoint(&params);
2932        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
2933        assert_eq!(
2934            endpoint,
2935            ::aws_smithy_types::endpoint::Endpoint::builder()
2936                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
2937                .property(
2938                    "authSchemes",
2939                    vec![::aws_smithy_types::Document::from({
2940                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2941                        out.insert("name".to_string(), "sigv4".to_string().into());
2942                        out.insert("signingName".to_string(), "s3".to_string().into());
2943                        out.insert("disableDoubleEncoding".to_string(), true.into());
2944                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2945                        out
2946                    })]
2947                )
2948                .build()
2949        );
2950    }
2951
2952    /// accelerate + dualstack + global endpoint
2953    #[test]
2954    fn test_102() {
2955        let params = crate::config::endpoint::Params::builder()
2956            .region("us-east-1".to_string())
2957            .bucket("bucket".to_string())
2958            .use_fips(false)
2959            .use_dual_stack(true)
2960            .accelerate(true)
2961            .use_global_endpoint(true)
2962            .build()
2963            .expect("invalid params");
2964        let resolver = crate::config::endpoint::DefaultResolver::new();
2965        let endpoint = resolver.resolve_endpoint(&params);
2966        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.dualstack.amazonaws.com");
2967        assert_eq!(
2968            endpoint,
2969            ::aws_smithy_types::endpoint::Endpoint::builder()
2970                .url("https://bucket.s3-accelerate.dualstack.amazonaws.com")
2971                .property(
2972                    "authSchemes",
2973                    vec![::aws_smithy_types::Document::from({
2974                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2975                        out.insert("name".to_string(), "sigv4".to_string().into());
2976                        out.insert("signingName".to_string(), "s3".to_string().into());
2977                        out.insert("disableDoubleEncoding".to_string(), true.into());
2978                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2979                        out
2980                    })]
2981                )
2982                .build()
2983        );
2984    }
2985
2986    /// dualstack + global endpoint + non URI safe bucket
2987    #[test]
2988    fn test_103() {
2989        let params = crate::config::endpoint::Params::builder()
2990            .region("us-east-1".to_string())
2991            .bucket("bucket!".to_string())
2992            .accelerate(false)
2993            .use_dual_stack(true)
2994            .use_fips(false)
2995            .use_global_endpoint(true)
2996            .build()
2997            .expect("invalid params");
2998        let resolver = crate::config::endpoint::DefaultResolver::new();
2999        let endpoint = resolver.resolve_endpoint(&params);
3000        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket%21");
3001        assert_eq!(
3002            endpoint,
3003            ::aws_smithy_types::endpoint::Endpoint::builder()
3004                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket%21")
3005                .property(
3006                    "authSchemes",
3007                    vec![::aws_smithy_types::Document::from({
3008                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3009                        out.insert("name".to_string(), "sigv4".to_string().into());
3010                        out.insert("signingName".to_string(), "s3".to_string().into());
3011                        out.insert("disableDoubleEncoding".to_string(), true.into());
3012                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3013                        out
3014                    })]
3015                )
3016                .build()
3017        );
3018    }
3019
3020    /// FIPS + uri encoded bucket
3021    #[test]
3022    fn test_104() {
3023        let params = crate::config::endpoint::Params::builder()
3024            .region("us-east-1".to_string())
3025            .bucket("bucket!".to_string())
3026            .force_path_style(true)
3027            .accelerate(false)
3028            .use_dual_stack(false)
3029            .use_fips(true)
3030            .use_global_endpoint(true)
3031            .build()
3032            .expect("invalid params");
3033        let resolver = crate::config::endpoint::DefaultResolver::new();
3034        let endpoint = resolver.resolve_endpoint(&params);
3035        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
3036        assert_eq!(
3037            endpoint,
3038            ::aws_smithy_types::endpoint::Endpoint::builder()
3039                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
3040                .property(
3041                    "authSchemes",
3042                    vec![::aws_smithy_types::Document::from({
3043                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3044                        out.insert("name".to_string(), "sigv4".to_string().into());
3045                        out.insert("signingName".to_string(), "s3".to_string().into());
3046                        out.insert("disableDoubleEncoding".to_string(), true.into());
3047                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3048                        out
3049                    })]
3050                )
3051                .build()
3052        );
3053    }
3054
3055    /// endpoint override + non-uri safe endpoint + force path style
3056    #[test]
3057    fn test_105() {
3058        let params = crate::config::endpoint::Params::builder()
3059            .region("us-east-1".to_string())
3060            .bucket("bucket!".to_string())
3061            .force_path_style(true)
3062            .accelerate(false)
3063            .use_dual_stack(false)
3064            .use_fips(true)
3065            .endpoint("http://foo.com".to_string())
3066            .use_global_endpoint(true)
3067            .build()
3068            .expect("invalid params");
3069        let resolver = crate::config::endpoint::DefaultResolver::new();
3070        let endpoint = resolver.resolve_endpoint(&params);
3071        let error = endpoint.expect_err(
3072            "expected error: A custom endpoint cannot be combined with FIPS [endpoint override + non-uri safe endpoint + force path style]",
3073        );
3074        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3075    }
3076
3077    /// FIPS + Dualstack + global endpoint + non-dns bucket
3078    #[test]
3079    fn test_106() {
3080        let params = crate::config::endpoint::Params::builder()
3081            .region("us-east-1".to_string())
3082            .bucket("bucket!".to_string())
3083            .accelerate(false)
3084            .use_dual_stack(true)
3085            .use_fips(true)
3086            .use_global_endpoint(true)
3087            .build()
3088            .expect("invalid params");
3089        let resolver = crate::config::endpoint::DefaultResolver::new();
3090        let endpoint = resolver.resolve_endpoint(&params);
3091        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
3092        assert_eq!(
3093            endpoint,
3094            ::aws_smithy_types::endpoint::Endpoint::builder()
3095                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
3096                .property(
3097                    "authSchemes",
3098                    vec![::aws_smithy_types::Document::from({
3099                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3100                        out.insert("name".to_string(), "sigv4".to_string().into());
3101                        out.insert("signingName".to_string(), "s3".to_string().into());
3102                        out.insert("disableDoubleEncoding".to_string(), true.into());
3103                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3104                        out
3105                    })]
3106                )
3107                .build()
3108        );
3109    }
3110
3111    /// endpoint override + FIPS + dualstack
3112    #[test]
3113    fn test_107() {
3114        let params = crate::config::endpoint::Params::builder()
3115            .region("us-east-1".to_string())
3116            .use_dual_stack(true)
3117            .use_fips(true)
3118            .use_global_endpoint(true)
3119            .endpoint("http://foo.com".to_string())
3120            .build()
3121            .expect("invalid params");
3122        let resolver = crate::config::endpoint::DefaultResolver::new();
3123        let endpoint = resolver.resolve_endpoint(&params);
3124        let error = endpoint
3125            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [endpoint override + FIPS + dualstack]");
3126        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3127    }
3128
3129    /// non-bucket endpoint override + dualstack + global endpoint
3130    #[test]
3131    fn test_108() {
3132        let params = crate::config::endpoint::Params::builder()
3133            .region("us-east-1".to_string())
3134            .use_fips(false)
3135            .use_dual_stack(true)
3136            .use_global_endpoint(true)
3137            .endpoint("http://foo.com".to_string())
3138            .build()
3139            .expect("invalid params");
3140        let resolver = crate::config::endpoint::DefaultResolver::new();
3141        let endpoint = resolver.resolve_endpoint(&params);
3142        let error = endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [non-bucket endpoint override + dualstack + global endpoint]");
3143        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3144    }
3145
3146    /// Endpoint override + UseGlobalEndpoint + us-east-1
3147    #[test]
3148    fn test_109() {
3149        let params = crate::config::endpoint::Params::builder()
3150            .region("us-east-1".to_string())
3151            .use_fips(true)
3152            .use_dual_stack(false)
3153            .use_global_endpoint(true)
3154            .endpoint("http://foo.com".to_string())
3155            .build()
3156            .expect("invalid params");
3157        let resolver = crate::config::endpoint::DefaultResolver::new();
3158        let endpoint = resolver.resolve_endpoint(&params);
3159        let error =
3160            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [Endpoint override + UseGlobalEndpoint + us-east-1]");
3161        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3162    }
3163
3164    /// non-FIPS partition with FIPS set + custom endpoint
3165    #[test]
3166    fn test_110() {
3167        let params = crate::config::endpoint::Params::builder()
3168            .region("cn-north-1".to_string())
3169            .use_fips(true)
3170            .use_dual_stack(false)
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("expected error: Partition does not support FIPS [non-FIPS partition with FIPS set + custom endpoint]");
3177        assert_eq!(format!("{}", error), "Partition does not support FIPS")
3178    }
3179
3180    /// aws-global signs as us-east-1
3181    #[test]
3182    fn test_111() {
3183        let params = crate::config::endpoint::Params::builder()
3184            .region("aws-global".to_string())
3185            .bucket("bucket!".to_string())
3186            .use_fips(true)
3187            .accelerate(false)
3188            .use_dual_stack(true)
3189            .build()
3190            .expect("invalid params");
3191        let resolver = crate::config::endpoint::DefaultResolver::new();
3192        let endpoint = resolver.resolve_endpoint(&params);
3193        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
3194        assert_eq!(
3195            endpoint,
3196            ::aws_smithy_types::endpoint::Endpoint::builder()
3197                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
3198                .property(
3199                    "authSchemes",
3200                    vec![::aws_smithy_types::Document::from({
3201                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3202                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3203                        out.insert("name".to_string(), "sigv4".to_string().into());
3204                        out.insert("signingName".to_string(), "s3".to_string().into());
3205                        out.insert("disableDoubleEncoding".to_string(), true.into());
3206                        out
3207                    })]
3208                )
3209                .build()
3210        );
3211    }
3212
3213    /// aws-global signs as us-east-1
3214    #[test]
3215    fn test_112() {
3216        let params = crate::config::endpoint::Params::builder()
3217            .region("aws-global".to_string())
3218            .bucket("bucket".to_string())
3219            .use_dual_stack(false)
3220            .use_fips(false)
3221            .accelerate(false)
3222            .endpoint("https://foo.com".to_string())
3223            .build()
3224            .expect("invalid params");
3225        let resolver = crate::config::endpoint::DefaultResolver::new();
3226        let endpoint = resolver.resolve_endpoint(&params);
3227        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.foo.com");
3228        assert_eq!(
3229            endpoint,
3230            ::aws_smithy_types::endpoint::Endpoint::builder()
3231                .url("https://bucket.foo.com")
3232                .property(
3233                    "authSchemes",
3234                    vec![::aws_smithy_types::Document::from({
3235                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3236                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3237                        out.insert("name".to_string(), "sigv4".to_string().into());
3238                        out.insert("signingName".to_string(), "s3".to_string().into());
3239                        out.insert("disableDoubleEncoding".to_string(), true.into());
3240                        out
3241                    })]
3242                )
3243                .build()
3244        );
3245    }
3246
3247    /// aws-global + dualstack + path-only bucket
3248    #[test]
3249    fn test_113() {
3250        let params = crate::config::endpoint::Params::builder()
3251            .region("aws-global".to_string())
3252            .bucket("bucket!".to_string())
3253            .use_dual_stack(true)
3254            .use_fips(false)
3255            .accelerate(false)
3256            .build()
3257            .expect("invalid params");
3258        let resolver = crate::config::endpoint::DefaultResolver::new();
3259        let endpoint = resolver.resolve_endpoint(&params);
3260        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket%21");
3261        assert_eq!(
3262            endpoint,
3263            ::aws_smithy_types::endpoint::Endpoint::builder()
3264                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket%21")
3265                .property(
3266                    "authSchemes",
3267                    vec![::aws_smithy_types::Document::from({
3268                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3269                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3270                        out.insert("name".to_string(), "sigv4".to_string().into());
3271                        out.insert("signingName".to_string(), "s3".to_string().into());
3272                        out.insert("disableDoubleEncoding".to_string(), true.into());
3273                        out
3274                    })]
3275                )
3276                .build()
3277        );
3278    }
3279
3280    /// aws-global + path-only bucket
3281    #[test]
3282    fn test_114() {
3283        let params = crate::config::endpoint::Params::builder()
3284            .region("aws-global".to_string())
3285            .bucket("bucket!".to_string())
3286            .build()
3287            .expect("invalid params");
3288        let resolver = crate::config::endpoint::DefaultResolver::new();
3289        let endpoint = resolver.resolve_endpoint(&params);
3290        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket%21");
3291        assert_eq!(
3292            endpoint,
3293            ::aws_smithy_types::endpoint::Endpoint::builder()
3294                .url("https://s3.amazonaws.com/bucket%21")
3295                .property(
3296                    "authSchemes",
3297                    vec![::aws_smithy_types::Document::from({
3298                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3299                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3300                        out.insert("name".to_string(), "sigv4".to_string().into());
3301                        out.insert("signingName".to_string(), "s3".to_string().into());
3302                        out.insert("disableDoubleEncoding".to_string(), true.into());
3303                        out
3304                    })]
3305                )
3306                .build()
3307        );
3308    }
3309
3310    /// aws-global + fips + custom endpoint
3311    #[test]
3312    fn test_115() {
3313        let params = crate::config::endpoint::Params::builder()
3314            .region("aws-global".to_string())
3315            .bucket("bucket!".to_string())
3316            .use_dual_stack(false)
3317            .use_fips(true)
3318            .accelerate(false)
3319            .endpoint("http://foo.com".to_string())
3320            .build()
3321            .expect("invalid params");
3322        let resolver = crate::config::endpoint::DefaultResolver::new();
3323        let endpoint = resolver.resolve_endpoint(&params);
3324        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [aws-global + fips + custom endpoint]");
3325        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3326    }
3327
3328    /// aws-global, endpoint override & path only-bucket
3329    #[test]
3330    fn test_116() {
3331        let params = crate::config::endpoint::Params::builder()
3332            .region("aws-global".to_string())
3333            .bucket("bucket!".to_string())
3334            .use_dual_stack(false)
3335            .use_fips(false)
3336            .accelerate(false)
3337            .endpoint("http://foo.com".to_string())
3338            .build()
3339            .expect("invalid params");
3340        let resolver = crate::config::endpoint::DefaultResolver::new();
3341        let endpoint = resolver.resolve_endpoint(&params);
3342        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
3343        assert_eq!(
3344            endpoint,
3345            ::aws_smithy_types::endpoint::Endpoint::builder()
3346                .url("http://foo.com/bucket%21")
3347                .property(
3348                    "authSchemes",
3349                    vec![::aws_smithy_types::Document::from({
3350                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3351                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3352                        out.insert("name".to_string(), "sigv4".to_string().into());
3353                        out.insert("signingName".to_string(), "s3".to_string().into());
3354                        out.insert("disableDoubleEncoding".to_string(), true.into());
3355                        out
3356                    })]
3357                )
3358                .build()
3359        );
3360    }
3361
3362    /// aws-global + dualstack + custom endpoint
3363    #[test]
3364    fn test_117() {
3365        let params = crate::config::endpoint::Params::builder()
3366            .region("aws-global".to_string())
3367            .use_dual_stack(true)
3368            .use_fips(false)
3369            .accelerate(false)
3370            .endpoint("http://foo.com".to_string())
3371            .build()
3372            .expect("invalid params");
3373        let resolver = crate::config::endpoint::DefaultResolver::new();
3374        let endpoint = resolver.resolve_endpoint(&params);
3375        let error = endpoint
3376            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [aws-global + dualstack + custom endpoint]");
3377        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3378    }
3379
3380    /// accelerate, dualstack + aws-global
3381    #[test]
3382    fn test_118() {
3383        let params = crate::config::endpoint::Params::builder()
3384            .region("aws-global".to_string())
3385            .bucket("bucket".to_string())
3386            .use_dual_stack(true)
3387            .use_fips(false)
3388            .accelerate(true)
3389            .build()
3390            .expect("invalid params");
3391        let resolver = crate::config::endpoint::DefaultResolver::new();
3392        let endpoint = resolver.resolve_endpoint(&params);
3393        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.dualstack.us-east-1.amazonaws.com");
3394        assert_eq!(
3395            endpoint,
3396            ::aws_smithy_types::endpoint::Endpoint::builder()
3397                .url("https://bucket.s3-accelerate.dualstack.us-east-1.amazonaws.com")
3398                .property(
3399                    "authSchemes",
3400                    vec![::aws_smithy_types::Document::from({
3401                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3402                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3403                        out.insert("name".to_string(), "sigv4".to_string().into());
3404                        out.insert("signingName".to_string(), "s3".to_string().into());
3405                        out.insert("disableDoubleEncoding".to_string(), true.into());
3406                        out
3407                    })]
3408                )
3409                .build()
3410        );
3411    }
3412
3413    /// FIPS + aws-global + path only bucket. This is not supported by S3 but we allow garbage in garbage out
3414    #[test]
3415    fn test_119() {
3416        let params = crate::config::endpoint::Params::builder()
3417            .region("aws-global".to_string())
3418            .bucket("bucket!".to_string())
3419            .force_path_style(true)
3420            .use_dual_stack(true)
3421            .use_fips(true)
3422            .accelerate(false)
3423            .build()
3424            .expect("invalid params");
3425        let resolver = crate::config::endpoint::DefaultResolver::new();
3426        let endpoint = resolver.resolve_endpoint(&params);
3427        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
3428        assert_eq!(
3429            endpoint,
3430            ::aws_smithy_types::endpoint::Endpoint::builder()
3431                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
3432                .property(
3433                    "authSchemes",
3434                    vec![::aws_smithy_types::Document::from({
3435                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3436                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3437                        out.insert("name".to_string(), "sigv4".to_string().into());
3438                        out.insert("signingName".to_string(), "s3".to_string().into());
3439                        out.insert("disableDoubleEncoding".to_string(), true.into());
3440                        out
3441                    })]
3442                )
3443                .build()
3444        );
3445    }
3446
3447    /// aws-global + FIPS + endpoint override.
3448    #[test]
3449    fn test_120() {
3450        let params = crate::config::endpoint::Params::builder()
3451            .region("aws-global".to_string())
3452            .use_fips(true)
3453            .endpoint("http://foo.com".to_string())
3454            .build()
3455            .expect("invalid params");
3456        let resolver = crate::config::endpoint::DefaultResolver::new();
3457        let endpoint = resolver.resolve_endpoint(&params);
3458        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [aws-global + FIPS + endpoint override.]");
3459        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3460    }
3461
3462    /// force path style, FIPS, aws-global & endpoint override
3463    #[test]
3464    fn test_121() {
3465        let params = crate::config::endpoint::Params::builder()
3466            .region("aws-global".to_string())
3467            .bucket("bucket!".to_string())
3468            .force_path_style(true)
3469            .use_fips(true)
3470            .endpoint("http://foo.com".to_string())
3471            .build()
3472            .expect("invalid params");
3473        let resolver = crate::config::endpoint::DefaultResolver::new();
3474        let endpoint = resolver.resolve_endpoint(&params);
3475        let error = endpoint
3476            .expect_err("expected error: A custom endpoint cannot be combined with FIPS [force path style, FIPS, aws-global & endpoint override]");
3477        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3478    }
3479
3480    /// ip address causes path style to be forced
3481    #[test]
3482    fn test_122() {
3483        let params = crate::config::endpoint::Params::builder()
3484            .region("aws-global".to_string())
3485            .bucket("bucket".to_string())
3486            .endpoint("http://192.168.1.1".to_string())
3487            .build()
3488            .expect("invalid params");
3489        let resolver = crate::config::endpoint::DefaultResolver::new();
3490        let endpoint = resolver.resolve_endpoint(&params);
3491        let endpoint = endpoint.expect("Expected valid endpoint: http://192.168.1.1/bucket");
3492        assert_eq!(
3493            endpoint,
3494            ::aws_smithy_types::endpoint::Endpoint::builder()
3495                .url("http://192.168.1.1/bucket")
3496                .property(
3497                    "authSchemes",
3498                    vec![::aws_smithy_types::Document::from({
3499                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3500                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3501                        out.insert("name".to_string(), "sigv4".to_string().into());
3502                        out.insert("signingName".to_string(), "s3".to_string().into());
3503                        out.insert("disableDoubleEncoding".to_string(), true.into());
3504                        out
3505                    })]
3506                )
3507                .build()
3508        );
3509    }
3510
3511    /// endpoint override with aws-global region
3512    #[test]
3513    fn test_123() {
3514        let params = crate::config::endpoint::Params::builder()
3515            .region("aws-global".to_string())
3516            .use_fips(true)
3517            .use_dual_stack(true)
3518            .endpoint("http://foo.com".to_string())
3519            .build()
3520            .expect("invalid params");
3521        let resolver = crate::config::endpoint::DefaultResolver::new();
3522        let endpoint = resolver.resolve_endpoint(&params);
3523        let error = endpoint
3524            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [endpoint override with aws-global region]");
3525        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3526    }
3527
3528    /// FIPS + path-only (TODO: consider making this an error)
3529    #[test]
3530    fn test_124() {
3531        let params = crate::config::endpoint::Params::builder()
3532            .region("aws-global".to_string())
3533            .bucket("bucket!".to_string())
3534            .use_fips(true)
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.us-east-1.amazonaws.com/bucket%21");
3540        assert_eq!(
3541            endpoint,
3542            ::aws_smithy_types::endpoint::Endpoint::builder()
3543                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
3544                .property(
3545                    "authSchemes",
3546                    vec![::aws_smithy_types::Document::from({
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                )
3555                .build()
3556        );
3557    }
3558
3559    /// empty arn type
3560    #[test]
3561    fn test_125() {
3562        let params = crate::config::endpoint::Params::builder()
3563            .region("us-east-2".to_string())
3564            .bucket("arn:aws:not-s3:us-west-2:123456789012::myendpoint".to_string())
3565            .build()
3566            .expect("invalid params");
3567        let resolver = crate::config::endpoint::DefaultResolver::new();
3568        let endpoint = resolver.resolve_endpoint(&params);
3569        let error = endpoint.expect_err("expected error: Invalid ARN: No ARN type specified [empty arn type]");
3570        assert_eq!(format!("{}", error), "Invalid ARN: No ARN type specified")
3571    }
3572
3573    /// path style can't be used with accelerate
3574    #[test]
3575    fn test_126() {
3576        let params = crate::config::endpoint::Params::builder()
3577            .region("us-east-2".to_string())
3578            .bucket("bucket!".to_string())
3579            .accelerate(true)
3580            .build()
3581            .expect("invalid params");
3582        let resolver = crate::config::endpoint::DefaultResolver::new();
3583        let endpoint = resolver.resolve_endpoint(&params);
3584        let error =
3585            endpoint.expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style can't be used with accelerate]");
3586        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
3587    }
3588
3589    /// invalid region
3590    #[test]
3591    fn test_127() {
3592        let params = crate::config::endpoint::Params::builder()
3593            .region("us-east-2!".to_string())
3594            .bucket("bucket.subdomain".to_string())
3595            .endpoint("http://foo.com".to_string())
3596            .build()
3597            .expect("invalid params");
3598        let resolver = crate::config::endpoint::DefaultResolver::new();
3599        let endpoint = resolver.resolve_endpoint(&params);
3600        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [invalid region]");
3601        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
3602    }
3603
3604    /// invalid region
3605    #[test]
3606    fn test_128() {
3607        let params = crate::config::endpoint::Params::builder()
3608            .region("us-east-2!".to_string())
3609            .bucket("bucket".to_string())
3610            .endpoint("http://foo.com".to_string())
3611            .build()
3612            .expect("invalid params");
3613        let resolver = crate::config::endpoint::DefaultResolver::new();
3614        let endpoint = resolver.resolve_endpoint(&params);
3615        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [invalid region]");
3616        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
3617    }
3618
3619    /// empty arn type
3620    #[test]
3621    fn test_129() {
3622        let params = crate::config::endpoint::Params::builder()
3623            .region("us-east-2".to_string())
3624            .bucket("arn:aws:s3::123456789012:accesspoint:my_endpoint".to_string())
3625            .build()
3626            .expect("invalid params");
3627        let resolver = crate::config::endpoint::DefaultResolver::new();
3628        let endpoint = resolver.resolve_endpoint(&params);
3629        let error = endpoint.expect_err("expected error: Invalid Access Point Name [empty arn type]");
3630        assert_eq!(format!("{}", error), "Invalid Access Point Name")
3631    }
3632
3633    /// empty arn type
3634    #[test]
3635    fn test_130() {
3636        let params = crate::config::endpoint::Params::builder()
3637            .region("us-east-2".to_string())
3638            .bucket("arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint".to_string())
3639            .use_arn_region(true)
3640            .build()
3641            .expect("invalid params");
3642        let resolver = crate::config::endpoint::DefaultResolver::new();
3643        let endpoint = resolver.resolve_endpoint(&params);
3644        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]");
3645        assert_eq!(
3646            format!("{}", error),
3647            "Client was configured for partition `aws` but ARN (`arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint`) has `aws-cn`"
3648        )
3649    }
3650
3651    /// invalid arn region
3652    #[test]
3653    fn test_131() {
3654        let params = crate::config::endpoint::Params::builder()
3655            .region("us-east-2".to_string())
3656            .bucket("arn:aws:s3-object-lambda:us-east_2:123456789012:accesspoint:my-endpoint".to_string())
3657            .use_arn_region(true)
3658            .build()
3659            .expect("invalid params");
3660        let resolver = crate::config::endpoint::DefaultResolver::new();
3661        let endpoint = resolver.resolve_endpoint(&params);
3662        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-east_2` (invalid DNS name) [invalid arn region]");
3663        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-east_2` (invalid DNS name)")
3664    }
3665
3666    /// invalid ARN outpost
3667    #[test]
3668    fn test_132() {
3669        let params = crate::config::endpoint::Params::builder()
3670            .region("us-east-2".to_string())
3671            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op_01234567890123456/accesspoint/reports".to_string())
3672            .use_arn_region(true)
3673            .build()
3674            .expect("invalid params");
3675        let resolver = crate::config::endpoint::DefaultResolver::new();
3676        let endpoint = resolver.resolve_endpoint(&params);
3677        let error = endpoint.expect_err(
3678            "expected error: Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `op_01234567890123456` [invalid ARN outpost]",
3679        );
3680        assert_eq!(
3681            format!("{}", error),
3682            "Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `op_01234567890123456`"
3683        )
3684    }
3685
3686    /// invalid ARN
3687    #[test]
3688    fn test_133() {
3689        let params = crate::config::endpoint::Params::builder()
3690            .region("us-east-2".to_string())
3691            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/reports".to_string())
3692            .build()
3693            .expect("invalid params");
3694        let resolver = crate::config::endpoint::DefaultResolver::new();
3695        let endpoint = resolver.resolve_endpoint(&params);
3696        let error = endpoint.expect_err("expected error: Invalid ARN: expected an access point name [invalid ARN]");
3697        assert_eq!(format!("{}", error), "Invalid ARN: expected an access point name")
3698    }
3699
3700    /// invalid ARN
3701    #[test]
3702    fn test_134() {
3703        let params = crate::config::endpoint::Params::builder()
3704            .region("us-east-2".to_string())
3705            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456".to_string())
3706            .build()
3707            .expect("invalid params");
3708        let resolver = crate::config::endpoint::DefaultResolver::new();
3709        let endpoint = resolver.resolve_endpoint(&params);
3710        let error = endpoint.expect_err("expected error: Invalid ARN: Expected a 4-component resource [invalid ARN]");
3711        assert_eq!(format!("{}", error), "Invalid ARN: Expected a 4-component resource")
3712    }
3713
3714    /// invalid outpost type
3715    #[test]
3716    fn test_135() {
3717        let params = crate::config::endpoint::Params::builder()
3718            .region("us-east-2".to_string())
3719            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3720            .build()
3721            .expect("invalid params");
3722        let resolver = crate::config::endpoint::DefaultResolver::new();
3723        let endpoint = resolver.resolve_endpoint(&params);
3724        let error = endpoint.expect_err("expected error: Expected an outpost type `accesspoint`, found not-accesspoint [invalid outpost type]");
3725        assert_eq!(format!("{}", error), "Expected an outpost type `accesspoint`, found not-accesspoint")
3726    }
3727
3728    /// invalid outpost type
3729    #[test]
3730    fn test_136() {
3731        let params = crate::config::endpoint::Params::builder()
3732            .region("us-east-2".to_string())
3733            .bucket("arn:aws:s3-outposts:us-east_1:123456789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3734            .build()
3735            .expect("invalid params");
3736        let resolver = crate::config::endpoint::DefaultResolver::new();
3737        let endpoint = resolver.resolve_endpoint(&params);
3738        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-east_1` (invalid DNS name) [invalid outpost type]");
3739        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-east_1` (invalid DNS name)")
3740    }
3741
3742    /// invalid outpost type
3743    #[test]
3744    fn test_137() {
3745        let params = crate::config::endpoint::Params::builder()
3746            .region("us-east-2".to_string())
3747            .bucket("arn:aws:s3-outposts:us-east-1:12345_789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3748            .build()
3749            .expect("invalid params");
3750        let resolver = crate::config::endpoint::DefaultResolver::new();
3751        let endpoint = resolver.resolve_endpoint(&params);
3752        let error = endpoint.expect_err(
3753            "expected error: Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `12345_789012` [invalid outpost type]",
3754        );
3755        assert_eq!(
3756            format!("{}", error),
3757            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `12345_789012`"
3758        )
3759    }
3760
3761    /// invalid outpost type
3762    #[test]
3763    fn test_138() {
3764        let params = crate::config::endpoint::Params::builder()
3765            .region("us-east-2".to_string())
3766            .bucket("arn:aws:s3-outposts:us-east-1:12345789012:outpost".to_string())
3767            .build()
3768            .expect("invalid params");
3769        let resolver = crate::config::endpoint::DefaultResolver::new();
3770        let endpoint = resolver.resolve_endpoint(&params);
3771        let error = endpoint.expect_err("expected error: Invalid ARN: The Outpost Id was not set [invalid outpost type]");
3772        assert_eq!(format!("{}", error), "Invalid ARN: The Outpost Id was not set")
3773    }
3774
3775    /// use global endpoint virtual addressing
3776    #[test]
3777    fn test_139() {
3778        let params = crate::config::endpoint::Params::builder()
3779            .region("us-east-2".to_string())
3780            .bucket("bucket".to_string())
3781            .endpoint("http://example.com".to_string())
3782            .use_global_endpoint(true)
3783            .build()
3784            .expect("invalid params");
3785        let resolver = crate::config::endpoint::DefaultResolver::new();
3786        let endpoint = resolver.resolve_endpoint(&params);
3787        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket.example.com");
3788        assert_eq!(
3789            endpoint,
3790            ::aws_smithy_types::endpoint::Endpoint::builder()
3791                .url("http://bucket.example.com")
3792                .property(
3793                    "authSchemes",
3794                    vec![::aws_smithy_types::Document::from({
3795                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3796                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3797                        out.insert("name".to_string(), "sigv4".to_string().into());
3798                        out.insert("signingName".to_string(), "s3".to_string().into());
3799                        out.insert("disableDoubleEncoding".to_string(), true.into());
3800                        out
3801                    })]
3802                )
3803                .build()
3804        );
3805    }
3806
3807    /// global endpoint + ip address
3808    #[test]
3809    fn test_140() {
3810        let params = crate::config::endpoint::Params::builder()
3811            .region("us-east-2".to_string())
3812            .bucket("bucket".to_string())
3813            .endpoint("http://192.168.0.1".to_string())
3814            .use_global_endpoint(true)
3815            .build()
3816            .expect("invalid params");
3817        let resolver = crate::config::endpoint::DefaultResolver::new();
3818        let endpoint = resolver.resolve_endpoint(&params);
3819        let endpoint = endpoint.expect("Expected valid endpoint: http://192.168.0.1/bucket");
3820        assert_eq!(
3821            endpoint,
3822            ::aws_smithy_types::endpoint::Endpoint::builder()
3823                .url("http://192.168.0.1/bucket")
3824                .property(
3825                    "authSchemes",
3826                    vec![::aws_smithy_types::Document::from({
3827                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3828                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3829                        out.insert("name".to_string(), "sigv4".to_string().into());
3830                        out.insert("signingName".to_string(), "s3".to_string().into());
3831                        out.insert("disableDoubleEncoding".to_string(), true.into());
3832                        out
3833                    })]
3834                )
3835                .build()
3836        );
3837    }
3838
3839    /// invalid outpost type
3840    #[test]
3841    fn test_141() {
3842        let params = crate::config::endpoint::Params::builder()
3843            .region("us-east-2".to_string())
3844            .bucket("bucket!".to_string())
3845            .use_global_endpoint(true)
3846            .build()
3847            .expect("invalid params");
3848        let resolver = crate::config::endpoint::DefaultResolver::new();
3849        let endpoint = resolver.resolve_endpoint(&params);
3850        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-2.amazonaws.com/bucket%21");
3851        assert_eq!(
3852            endpoint,
3853            ::aws_smithy_types::endpoint::Endpoint::builder()
3854                .url("https://s3.us-east-2.amazonaws.com/bucket%21")
3855                .property(
3856                    "authSchemes",
3857                    vec![::aws_smithy_types::Document::from({
3858                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3859                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3860                        out.insert("name".to_string(), "sigv4".to_string().into());
3861                        out.insert("signingName".to_string(), "s3".to_string().into());
3862                        out.insert("disableDoubleEncoding".to_string(), true.into());
3863                        out
3864                    })]
3865                )
3866                .build()
3867        );
3868    }
3869
3870    /// invalid outpost type
3871    #[test]
3872    fn test_142() {
3873        let params = crate::config::endpoint::Params::builder()
3874            .region("us-east-2".to_string())
3875            .bucket("bucket".to_string())
3876            .accelerate(true)
3877            .use_global_endpoint(true)
3878            .build()
3879            .expect("invalid params");
3880        let resolver = crate::config::endpoint::DefaultResolver::new();
3881        let endpoint = resolver.resolve_endpoint(&params);
3882        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.amazonaws.com");
3883        assert_eq!(
3884            endpoint,
3885            ::aws_smithy_types::endpoint::Endpoint::builder()
3886                .url("https://bucket.s3-accelerate.amazonaws.com")
3887                .property(
3888                    "authSchemes",
3889                    vec![::aws_smithy_types::Document::from({
3890                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3891                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3892                        out.insert("name".to_string(), "sigv4".to_string().into());
3893                        out.insert("signingName".to_string(), "s3".to_string().into());
3894                        out.insert("disableDoubleEncoding".to_string(), true.into());
3895                        out
3896                    })]
3897                )
3898                .build()
3899        );
3900    }
3901
3902    /// use global endpoint + custom endpoint
3903    #[test]
3904    fn test_143() {
3905        let params = crate::config::endpoint::Params::builder()
3906            .region("us-east-2".to_string())
3907            .bucket("bucket!".to_string())
3908            .use_global_endpoint(true)
3909            .endpoint("http://foo.com".to_string())
3910            .build()
3911            .expect("invalid params");
3912        let resolver = crate::config::endpoint::DefaultResolver::new();
3913        let endpoint = resolver.resolve_endpoint(&params);
3914        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
3915        assert_eq!(
3916            endpoint,
3917            ::aws_smithy_types::endpoint::Endpoint::builder()
3918                .url("http://foo.com/bucket%21")
3919                .property(
3920                    "authSchemes",
3921                    vec![::aws_smithy_types::Document::from({
3922                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3923                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3924                        out.insert("name".to_string(), "sigv4".to_string().into());
3925                        out.insert("signingName".to_string(), "s3".to_string().into());
3926                        out.insert("disableDoubleEncoding".to_string(), true.into());
3927                        out
3928                    })]
3929                )
3930                .build()
3931        );
3932    }
3933
3934    /// use global endpoint, not us-east-1, force path style
3935    #[test]
3936    fn test_144() {
3937        let params = crate::config::endpoint::Params::builder()
3938            .region("us-east-2".to_string())
3939            .bucket("bucket!".to_string())
3940            .use_global_endpoint(true)
3941            .force_path_style(true)
3942            .endpoint("http://foo.com".to_string())
3943            .build()
3944            .expect("invalid params");
3945        let resolver = crate::config::endpoint::DefaultResolver::new();
3946        let endpoint = resolver.resolve_endpoint(&params);
3947        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
3948        assert_eq!(
3949            endpoint,
3950            ::aws_smithy_types::endpoint::Endpoint::builder()
3951                .url("http://foo.com/bucket%21")
3952                .property(
3953                    "authSchemes",
3954                    vec![::aws_smithy_types::Document::from({
3955                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3956                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3957                        out.insert("name".to_string(), "sigv4".to_string().into());
3958                        out.insert("signingName".to_string(), "s3".to_string().into());
3959                        out.insert("disableDoubleEncoding".to_string(), true.into());
3960                        out
3961                    })]
3962                )
3963                .build()
3964        );
3965    }
3966
3967    /// vanilla virtual addressing@us-west-2
3968    #[test]
3969    fn test_145() {
3970        let params = crate::config::endpoint::Params::builder()
3971            .accelerate(false)
3972            .bucket("bucket-name".to_string())
3973            .force_path_style(false)
3974            .region("us-west-2".to_string())
3975            .use_dual_stack(false)
3976            .use_fips(false)
3977            .build()
3978            .expect("invalid params");
3979        let resolver = crate::config::endpoint::DefaultResolver::new();
3980        let endpoint = resolver.resolve_endpoint(&params);
3981        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.us-west-2.amazonaws.com");
3982        assert_eq!(
3983            endpoint,
3984            ::aws_smithy_types::endpoint::Endpoint::builder()
3985                .url("https://bucket-name.s3.us-west-2.amazonaws.com")
3986                .property(
3987                    "authSchemes",
3988                    vec![::aws_smithy_types::Document::from({
3989                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3990                        out.insert("name".to_string(), "sigv4".to_string().into());
3991                        out.insert("signingName".to_string(), "s3".to_string().into());
3992                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
3993                        out.insert("disableDoubleEncoding".to_string(), true.into());
3994                        out
3995                    })]
3996                )
3997                .build()
3998        );
3999    }
4000
4001    /// virtual addressing + dualstack@us-west-2
4002    #[test]
4003    fn test_146() {
4004        let params = crate::config::endpoint::Params::builder()
4005            .accelerate(false)
4006            .bucket("bucket-name".to_string())
4007            .force_path_style(false)
4008            .region("us-west-2".to_string())
4009            .use_dual_stack(true)
4010            .use_fips(false)
4011            .build()
4012            .expect("invalid params");
4013        let resolver = crate::config::endpoint::DefaultResolver::new();
4014        let endpoint = resolver.resolve_endpoint(&params);
4015        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-west-2.amazonaws.com");
4016        assert_eq!(
4017            endpoint,
4018            ::aws_smithy_types::endpoint::Endpoint::builder()
4019                .url("https://bucket-name.s3.dualstack.us-west-2.amazonaws.com")
4020                .property(
4021                    "authSchemes",
4022                    vec![::aws_smithy_types::Document::from({
4023                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4024                        out.insert("name".to_string(), "sigv4".to_string().into());
4025                        out.insert("signingName".to_string(), "s3".to_string().into());
4026                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4027                        out.insert("disableDoubleEncoding".to_string(), true.into());
4028                        out
4029                    })]
4030                )
4031                .build()
4032        );
4033    }
4034
4035    /// accelerate + dualstack@us-west-2
4036    #[test]
4037    fn test_147() {
4038        let params = crate::config::endpoint::Params::builder()
4039            .accelerate(true)
4040            .bucket("bucket-name".to_string())
4041            .force_path_style(false)
4042            .region("us-west-2".to_string())
4043            .use_dual_stack(true)
4044            .use_fips(false)
4045            .build()
4046            .expect("invalid params");
4047        let resolver = crate::config::endpoint::DefaultResolver::new();
4048        let endpoint = resolver.resolve_endpoint(&params);
4049        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.dualstack.amazonaws.com");
4050        assert_eq!(
4051            endpoint,
4052            ::aws_smithy_types::endpoint::Endpoint::builder()
4053                .url("https://bucket-name.s3-accelerate.dualstack.amazonaws.com")
4054                .property(
4055                    "authSchemes",
4056                    vec![::aws_smithy_types::Document::from({
4057                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4058                        out.insert("name".to_string(), "sigv4".to_string().into());
4059                        out.insert("signingName".to_string(), "s3".to_string().into());
4060                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4061                        out.insert("disableDoubleEncoding".to_string(), true.into());
4062                        out
4063                    })]
4064                )
4065                .build()
4066        );
4067    }
4068
4069    /// accelerate (dualstack=false)@us-west-2
4070    #[test]
4071    fn test_148() {
4072        let params = crate::config::endpoint::Params::builder()
4073            .accelerate(true)
4074            .bucket("bucket-name".to_string())
4075            .force_path_style(false)
4076            .region("us-west-2".to_string())
4077            .use_dual_stack(false)
4078            .use_fips(false)
4079            .build()
4080            .expect("invalid params");
4081        let resolver = crate::config::endpoint::DefaultResolver::new();
4082        let endpoint = resolver.resolve_endpoint(&params);
4083        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
4084        assert_eq!(
4085            endpoint,
4086            ::aws_smithy_types::endpoint::Endpoint::builder()
4087                .url("https://bucket-name.s3-accelerate.amazonaws.com")
4088                .property(
4089                    "authSchemes",
4090                    vec![::aws_smithy_types::Document::from({
4091                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4092                        out.insert("name".to_string(), "sigv4".to_string().into());
4093                        out.insert("signingName".to_string(), "s3".to_string().into());
4094                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4095                        out.insert("disableDoubleEncoding".to_string(), true.into());
4096                        out
4097                    })]
4098                )
4099                .build()
4100        );
4101    }
4102
4103    /// virtual addressing + fips@us-west-2
4104    #[test]
4105    fn test_149() {
4106        let params = crate::config::endpoint::Params::builder()
4107            .accelerate(false)
4108            .bucket("bucket-name".to_string())
4109            .force_path_style(false)
4110            .region("us-west-2".to_string())
4111            .use_dual_stack(false)
4112            .use_fips(true)
4113            .build()
4114            .expect("invalid params");
4115        let resolver = crate::config::endpoint::DefaultResolver::new();
4116        let endpoint = resolver.resolve_endpoint(&params);
4117        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-west-2.amazonaws.com");
4118        assert_eq!(
4119            endpoint,
4120            ::aws_smithy_types::endpoint::Endpoint::builder()
4121                .url("https://bucket-name.s3-fips.us-west-2.amazonaws.com")
4122                .property(
4123                    "authSchemes",
4124                    vec![::aws_smithy_types::Document::from({
4125                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4126                        out.insert("name".to_string(), "sigv4".to_string().into());
4127                        out.insert("signingName".to_string(), "s3".to_string().into());
4128                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4129                        out.insert("disableDoubleEncoding".to_string(), true.into());
4130                        out
4131                    })]
4132                )
4133                .build()
4134        );
4135    }
4136
4137    /// virtual addressing + dualstack + fips@us-west-2
4138    #[test]
4139    fn test_150() {
4140        let params = crate::config::endpoint::Params::builder()
4141            .accelerate(false)
4142            .bucket("bucket-name".to_string())
4143            .force_path_style(false)
4144            .region("us-west-2".to_string())
4145            .use_dual_stack(true)
4146            .use_fips(true)
4147            .build()
4148            .expect("invalid params");
4149        let resolver = crate::config::endpoint::DefaultResolver::new();
4150        let endpoint = resolver.resolve_endpoint(&params);
4151        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.us-west-2.amazonaws.com");
4152        assert_eq!(
4153            endpoint,
4154            ::aws_smithy_types::endpoint::Endpoint::builder()
4155                .url("https://bucket-name.s3-fips.dualstack.us-west-2.amazonaws.com")
4156                .property(
4157                    "authSchemes",
4158                    vec![::aws_smithy_types::Document::from({
4159                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4160                        out.insert("name".to_string(), "sigv4".to_string().into());
4161                        out.insert("signingName".to_string(), "s3".to_string().into());
4162                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4163                        out.insert("disableDoubleEncoding".to_string(), true.into());
4164                        out
4165                    })]
4166                )
4167                .build()
4168        );
4169    }
4170
4171    /// accelerate + fips = error@us-west-2
4172    #[test]
4173    fn test_151() {
4174        let params = crate::config::endpoint::Params::builder()
4175            .accelerate(true)
4176            .bucket("bucket-name".to_string())
4177            .force_path_style(false)
4178            .region("us-west-2".to_string())
4179            .use_dual_stack(false)
4180            .use_fips(true)
4181            .build()
4182            .expect("invalid params");
4183        let resolver = crate::config::endpoint::DefaultResolver::new();
4184        let endpoint = resolver.resolve_endpoint(&params);
4185        let error = endpoint.expect_err("expected error: Accelerate cannot be used with FIPS [accelerate + fips = error@us-west-2]");
4186        assert_eq!(format!("{}", error), "Accelerate cannot be used with FIPS")
4187    }
4188
4189    /// vanilla virtual addressing@cn-north-1
4190    #[test]
4191    fn test_152() {
4192        let params = crate::config::endpoint::Params::builder()
4193            .accelerate(false)
4194            .bucket("bucket-name".to_string())
4195            .force_path_style(false)
4196            .region("cn-north-1".to_string())
4197            .use_dual_stack(false)
4198            .use_fips(false)
4199            .build()
4200            .expect("invalid params");
4201        let resolver = crate::config::endpoint::DefaultResolver::new();
4202        let endpoint = resolver.resolve_endpoint(&params);
4203        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.cn-north-1.amazonaws.com.cn");
4204        assert_eq!(
4205            endpoint,
4206            ::aws_smithy_types::endpoint::Endpoint::builder()
4207                .url("https://bucket-name.s3.cn-north-1.amazonaws.com.cn")
4208                .property(
4209                    "authSchemes",
4210                    vec![::aws_smithy_types::Document::from({
4211                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4212                        out.insert("name".to_string(), "sigv4".to_string().into());
4213                        out.insert("signingName".to_string(), "s3".to_string().into());
4214                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4215                        out.insert("disableDoubleEncoding".to_string(), true.into());
4216                        out
4217                    })]
4218                )
4219                .build()
4220        );
4221    }
4222
4223    /// virtual addressing + dualstack@cn-north-1
4224    #[test]
4225    fn test_153() {
4226        let params = crate::config::endpoint::Params::builder()
4227            .accelerate(false)
4228            .bucket("bucket-name".to_string())
4229            .force_path_style(false)
4230            .region("cn-north-1".to_string())
4231            .use_dual_stack(true)
4232            .use_fips(false)
4233            .build()
4234            .expect("invalid params");
4235        let resolver = crate::config::endpoint::DefaultResolver::new();
4236        let endpoint = resolver.resolve_endpoint(&params);
4237        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.cn-north-1.amazonaws.com.cn");
4238        assert_eq!(
4239            endpoint,
4240            ::aws_smithy_types::endpoint::Endpoint::builder()
4241                .url("https://bucket-name.s3.dualstack.cn-north-1.amazonaws.com.cn")
4242                .property(
4243                    "authSchemes",
4244                    vec![::aws_smithy_types::Document::from({
4245                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4246                        out.insert("name".to_string(), "sigv4".to_string().into());
4247                        out.insert("signingName".to_string(), "s3".to_string().into());
4248                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4249                        out.insert("disableDoubleEncoding".to_string(), true.into());
4250                        out
4251                    })]
4252                )
4253                .build()
4254        );
4255    }
4256
4257    /// accelerate (dualstack=false)@cn-north-1
4258    #[test]
4259    fn test_154() {
4260        let params = crate::config::endpoint::Params::builder()
4261            .accelerate(true)
4262            .bucket("bucket-name".to_string())
4263            .force_path_style(false)
4264            .region("cn-north-1".to_string())
4265            .use_dual_stack(false)
4266            .use_fips(false)
4267            .build()
4268            .expect("invalid params");
4269        let resolver = crate::config::endpoint::DefaultResolver::new();
4270        let endpoint = resolver.resolve_endpoint(&params);
4271        let error = endpoint.expect_err("expected error: S3 Accelerate cannot be used in this region [accelerate (dualstack=false)@cn-north-1]");
4272        assert_eq!(format!("{}", error), "S3 Accelerate cannot be used in this region")
4273    }
4274
4275    /// virtual addressing + fips@cn-north-1
4276    #[test]
4277    fn test_155() {
4278        let params = crate::config::endpoint::Params::builder()
4279            .accelerate(false)
4280            .bucket("bucket-name".to_string())
4281            .force_path_style(false)
4282            .region("cn-north-1".to_string())
4283            .use_dual_stack(false)
4284            .use_fips(true)
4285            .build()
4286            .expect("invalid params");
4287        let resolver = crate::config::endpoint::DefaultResolver::new();
4288        let endpoint = resolver.resolve_endpoint(&params);
4289        let error = endpoint.expect_err("expected error: Partition does not support FIPS [virtual addressing + fips@cn-north-1]");
4290        assert_eq!(format!("{}", error), "Partition does not support FIPS")
4291    }
4292
4293    /// vanilla virtual addressing@af-south-1
4294    #[test]
4295    fn test_156() {
4296        let params = crate::config::endpoint::Params::builder()
4297            .accelerate(false)
4298            .bucket("bucket-name".to_string())
4299            .force_path_style(false)
4300            .region("af-south-1".to_string())
4301            .use_dual_stack(false)
4302            .use_fips(false)
4303            .build()
4304            .expect("invalid params");
4305        let resolver = crate::config::endpoint::DefaultResolver::new();
4306        let endpoint = resolver.resolve_endpoint(&params);
4307        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.af-south-1.amazonaws.com");
4308        assert_eq!(
4309            endpoint,
4310            ::aws_smithy_types::endpoint::Endpoint::builder()
4311                .url("https://bucket-name.s3.af-south-1.amazonaws.com")
4312                .property(
4313                    "authSchemes",
4314                    vec![::aws_smithy_types::Document::from({
4315                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4316                        out.insert("name".to_string(), "sigv4".to_string().into());
4317                        out.insert("signingName".to_string(), "s3".to_string().into());
4318                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4319                        out.insert("disableDoubleEncoding".to_string(), true.into());
4320                        out
4321                    })]
4322                )
4323                .build()
4324        );
4325    }
4326
4327    /// virtual addressing + dualstack@af-south-1
4328    #[test]
4329    fn test_157() {
4330        let params = crate::config::endpoint::Params::builder()
4331            .accelerate(false)
4332            .bucket("bucket-name".to_string())
4333            .force_path_style(false)
4334            .region("af-south-1".to_string())
4335            .use_dual_stack(true)
4336            .use_fips(false)
4337            .build()
4338            .expect("invalid params");
4339        let resolver = crate::config::endpoint::DefaultResolver::new();
4340        let endpoint = resolver.resolve_endpoint(&params);
4341        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.af-south-1.amazonaws.com");
4342        assert_eq!(
4343            endpoint,
4344            ::aws_smithy_types::endpoint::Endpoint::builder()
4345                .url("https://bucket-name.s3.dualstack.af-south-1.amazonaws.com")
4346                .property(
4347                    "authSchemes",
4348                    vec![::aws_smithy_types::Document::from({
4349                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4350                        out.insert("name".to_string(), "sigv4".to_string().into());
4351                        out.insert("signingName".to_string(), "s3".to_string().into());
4352                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4353                        out.insert("disableDoubleEncoding".to_string(), true.into());
4354                        out
4355                    })]
4356                )
4357                .build()
4358        );
4359    }
4360
4361    /// accelerate + dualstack@af-south-1
4362    #[test]
4363    fn test_158() {
4364        let params = crate::config::endpoint::Params::builder()
4365            .accelerate(true)
4366            .bucket("bucket-name".to_string())
4367            .force_path_style(false)
4368            .region("af-south-1".to_string())
4369            .use_dual_stack(true)
4370            .use_fips(false)
4371            .build()
4372            .expect("invalid params");
4373        let resolver = crate::config::endpoint::DefaultResolver::new();
4374        let endpoint = resolver.resolve_endpoint(&params);
4375        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.dualstack.amazonaws.com");
4376        assert_eq!(
4377            endpoint,
4378            ::aws_smithy_types::endpoint::Endpoint::builder()
4379                .url("https://bucket-name.s3-accelerate.dualstack.amazonaws.com")
4380                .property(
4381                    "authSchemes",
4382                    vec![::aws_smithy_types::Document::from({
4383                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4384                        out.insert("name".to_string(), "sigv4".to_string().into());
4385                        out.insert("signingName".to_string(), "s3".to_string().into());
4386                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4387                        out.insert("disableDoubleEncoding".to_string(), true.into());
4388                        out
4389                    })]
4390                )
4391                .build()
4392        );
4393    }
4394
4395    /// accelerate (dualstack=false)@af-south-1
4396    #[test]
4397    fn test_159() {
4398        let params = crate::config::endpoint::Params::builder()
4399            .accelerate(true)
4400            .bucket("bucket-name".to_string())
4401            .force_path_style(false)
4402            .region("af-south-1".to_string())
4403            .use_dual_stack(false)
4404            .use_fips(false)
4405            .build()
4406            .expect("invalid params");
4407        let resolver = crate::config::endpoint::DefaultResolver::new();
4408        let endpoint = resolver.resolve_endpoint(&params);
4409        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
4410        assert_eq!(
4411            endpoint,
4412            ::aws_smithy_types::endpoint::Endpoint::builder()
4413                .url("https://bucket-name.s3-accelerate.amazonaws.com")
4414                .property(
4415                    "authSchemes",
4416                    vec![::aws_smithy_types::Document::from({
4417                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4418                        out.insert("name".to_string(), "sigv4".to_string().into());
4419                        out.insert("signingName".to_string(), "s3".to_string().into());
4420                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4421                        out.insert("disableDoubleEncoding".to_string(), true.into());
4422                        out
4423                    })]
4424                )
4425                .build()
4426        );
4427    }
4428
4429    /// virtual addressing + fips@af-south-1
4430    #[test]
4431    fn test_160() {
4432        let params = crate::config::endpoint::Params::builder()
4433            .accelerate(false)
4434            .bucket("bucket-name".to_string())
4435            .force_path_style(false)
4436            .region("af-south-1".to_string())
4437            .use_dual_stack(false)
4438            .use_fips(true)
4439            .build()
4440            .expect("invalid params");
4441        let resolver = crate::config::endpoint::DefaultResolver::new();
4442        let endpoint = resolver.resolve_endpoint(&params);
4443        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.af-south-1.amazonaws.com");
4444        assert_eq!(
4445            endpoint,
4446            ::aws_smithy_types::endpoint::Endpoint::builder()
4447                .url("https://bucket-name.s3-fips.af-south-1.amazonaws.com")
4448                .property(
4449                    "authSchemes",
4450                    vec![::aws_smithy_types::Document::from({
4451                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4452                        out.insert("name".to_string(), "sigv4".to_string().into());
4453                        out.insert("signingName".to_string(), "s3".to_string().into());
4454                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4455                        out.insert("disableDoubleEncoding".to_string(), true.into());
4456                        out
4457                    })]
4458                )
4459                .build()
4460        );
4461    }
4462
4463    /// virtual addressing + dualstack + fips@af-south-1
4464    #[test]
4465    fn test_161() {
4466        let params = crate::config::endpoint::Params::builder()
4467            .accelerate(false)
4468            .bucket("bucket-name".to_string())
4469            .force_path_style(false)
4470            .region("af-south-1".to_string())
4471            .use_dual_stack(true)
4472            .use_fips(true)
4473            .build()
4474            .expect("invalid params");
4475        let resolver = crate::config::endpoint::DefaultResolver::new();
4476        let endpoint = resolver.resolve_endpoint(&params);
4477        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.af-south-1.amazonaws.com");
4478        assert_eq!(
4479            endpoint,
4480            ::aws_smithy_types::endpoint::Endpoint::builder()
4481                .url("https://bucket-name.s3-fips.dualstack.af-south-1.amazonaws.com")
4482                .property(
4483                    "authSchemes",
4484                    vec![::aws_smithy_types::Document::from({
4485                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4486                        out.insert("name".to_string(), "sigv4".to_string().into());
4487                        out.insert("signingName".to_string(), "s3".to_string().into());
4488                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4489                        out.insert("disableDoubleEncoding".to_string(), true.into());
4490                        out
4491                    })]
4492                )
4493                .build()
4494        );
4495    }
4496
4497    /// accelerate + fips = error@af-south-1
4498    #[test]
4499    fn test_162() {
4500        let params = crate::config::endpoint::Params::builder()
4501            .accelerate(true)
4502            .bucket("bucket-name".to_string())
4503            .force_path_style(false)
4504            .region("af-south-1".to_string())
4505            .use_dual_stack(false)
4506            .use_fips(true)
4507            .build()
4508            .expect("invalid params");
4509        let resolver = crate::config::endpoint::DefaultResolver::new();
4510        let endpoint = resolver.resolve_endpoint(&params);
4511        let error = endpoint.expect_err("expected error: Accelerate cannot be used with FIPS [accelerate + fips = error@af-south-1]");
4512        assert_eq!(format!("{}", error), "Accelerate cannot be used with FIPS")
4513    }
4514
4515    /// vanilla path style@us-west-2
4516    #[test]
4517    fn test_163() {
4518        let params = crate::config::endpoint::Params::builder()
4519            .accelerate(false)
4520            .bucket("bucket-name".to_string())
4521            .force_path_style(true)
4522            .region("us-west-2".to_string())
4523            .use_dual_stack(false)
4524            .use_fips(false)
4525            .build()
4526            .expect("invalid params");
4527        let resolver = crate::config::endpoint::DefaultResolver::new();
4528        let endpoint = resolver.resolve_endpoint(&params);
4529        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket-name");
4530        assert_eq!(
4531            endpoint,
4532            ::aws_smithy_types::endpoint::Endpoint::builder()
4533                .url("https://s3.us-west-2.amazonaws.com/bucket-name")
4534                .property(
4535                    "authSchemes",
4536                    vec![::aws_smithy_types::Document::from({
4537                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4538                        out.insert("name".to_string(), "sigv4".to_string().into());
4539                        out.insert("signingName".to_string(), "s3".to_string().into());
4540                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4541                        out.insert("disableDoubleEncoding".to_string(), true.into());
4542                        out
4543                    })]
4544                )
4545                .build()
4546        );
4547    }
4548
4549    /// fips@us-gov-west-2, bucket is not S3-dns-compatible (subdomains)
4550    #[test]
4551    fn test_164() {
4552        let params = crate::config::endpoint::Params::builder()
4553            .accelerate(false)
4554            .bucket("bucket.with.dots".to_string())
4555            .region("us-gov-west-1".to_string())
4556            .use_dual_stack(false)
4557            .use_fips(true)
4558            .build()
4559            .expect("invalid params");
4560        let resolver = crate::config::endpoint::DefaultResolver::new();
4561        let endpoint = resolver.resolve_endpoint(&params);
4562        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-gov-west-1.amazonaws.com/bucket.with.dots");
4563        assert_eq!(
4564            endpoint,
4565            ::aws_smithy_types::endpoint::Endpoint::builder()
4566                .url("https://s3-fips.us-gov-west-1.amazonaws.com/bucket.with.dots")
4567                .property(
4568                    "authSchemes",
4569                    vec![::aws_smithy_types::Document::from({
4570                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4571                        out.insert("signingName".to_string(), "s3".to_string().into());
4572                        out.insert("signingRegion".to_string(), "us-gov-west-1".to_string().into());
4573                        out.insert("disableDoubleEncoding".to_string(), true.into());
4574                        out.insert("name".to_string(), "sigv4".to_string().into());
4575                        out
4576                    })]
4577                )
4578                .build()
4579        );
4580    }
4581
4582    /// path style + accelerate = error@us-west-2
4583    #[test]
4584    fn test_165() {
4585        let params = crate::config::endpoint::Params::builder()
4586            .accelerate(true)
4587            .bucket("bucket-name".to_string())
4588            .force_path_style(true)
4589            .region("us-west-2".to_string())
4590            .use_dual_stack(false)
4591            .use_fips(false)
4592            .build()
4593            .expect("invalid params");
4594        let resolver = crate::config::endpoint::DefaultResolver::new();
4595        let endpoint = resolver.resolve_endpoint(&params);
4596        let error = endpoint
4597            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@us-west-2]");
4598        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
4599    }
4600
4601    /// path style + dualstack@us-west-2
4602    #[test]
4603    fn test_166() {
4604        let params = crate::config::endpoint::Params::builder()
4605            .accelerate(false)
4606            .bucket("bucket-name".to_string())
4607            .force_path_style(true)
4608            .region("us-west-2".to_string())
4609            .use_dual_stack(true)
4610            .use_fips(false)
4611            .build()
4612            .expect("invalid params");
4613        let resolver = crate::config::endpoint::DefaultResolver::new();
4614        let endpoint = resolver.resolve_endpoint(&params);
4615        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/bucket-name");
4616        assert_eq!(
4617            endpoint,
4618            ::aws_smithy_types::endpoint::Endpoint::builder()
4619                .url("https://s3.dualstack.us-west-2.amazonaws.com/bucket-name")
4620                .property(
4621                    "authSchemes",
4622                    vec![::aws_smithy_types::Document::from({
4623                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4624                        out.insert("name".to_string(), "sigv4".to_string().into());
4625                        out.insert("signingName".to_string(), "s3".to_string().into());
4626                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4627                        out.insert("disableDoubleEncoding".to_string(), true.into());
4628                        out
4629                    })]
4630                )
4631                .build()
4632        );
4633    }
4634
4635    /// path style + arn is error@us-west-2
4636    #[test]
4637    fn test_167() {
4638        let params = crate::config::endpoint::Params::builder()
4639            .accelerate(false)
4640            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
4641            .force_path_style(true)
4642            .region("us-west-2".to_string())
4643            .use_dual_stack(false)
4644            .use_fips(false)
4645            .build()
4646            .expect("invalid params");
4647        let resolver = crate::config::endpoint::DefaultResolver::new();
4648        let endpoint = resolver.resolve_endpoint(&params);
4649        let error =
4650            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@us-west-2]");
4651        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
4652    }
4653
4654    /// path style + invalid DNS name@us-west-2
4655    #[test]
4656    fn test_168() {
4657        let params = crate::config::endpoint::Params::builder()
4658            .accelerate(false)
4659            .bucket("99a_b".to_string())
4660            .force_path_style(true)
4661            .region("us-west-2".to_string())
4662            .use_dual_stack(false)
4663            .use_fips(false)
4664            .build()
4665            .expect("invalid params");
4666        let resolver = crate::config::endpoint::DefaultResolver::new();
4667        let endpoint = resolver.resolve_endpoint(&params);
4668        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/99a_b");
4669        assert_eq!(
4670            endpoint,
4671            ::aws_smithy_types::endpoint::Endpoint::builder()
4672                .url("https://s3.us-west-2.amazonaws.com/99a_b")
4673                .property(
4674                    "authSchemes",
4675                    vec![::aws_smithy_types::Document::from({
4676                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4677                        out.insert("name".to_string(), "sigv4".to_string().into());
4678                        out.insert("signingName".to_string(), "s3".to_string().into());
4679                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4680                        out.insert("disableDoubleEncoding".to_string(), true.into());
4681                        out
4682                    })]
4683                )
4684                .build()
4685        );
4686    }
4687
4688    /// no path style + invalid DNS name@us-west-2
4689    #[test]
4690    fn test_169() {
4691        let params = crate::config::endpoint::Params::builder()
4692            .accelerate(false)
4693            .bucket("99a_b".to_string())
4694            .region("us-west-2".to_string())
4695            .use_dual_stack(false)
4696            .use_fips(false)
4697            .build()
4698            .expect("invalid params");
4699        let resolver = crate::config::endpoint::DefaultResolver::new();
4700        let endpoint = resolver.resolve_endpoint(&params);
4701        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/99a_b");
4702        assert_eq!(
4703            endpoint,
4704            ::aws_smithy_types::endpoint::Endpoint::builder()
4705                .url("https://s3.us-west-2.amazonaws.com/99a_b")
4706                .property(
4707                    "authSchemes",
4708                    vec![::aws_smithy_types::Document::from({
4709                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4710                        out.insert("name".to_string(), "sigv4".to_string().into());
4711                        out.insert("signingName".to_string(), "s3".to_string().into());
4712                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4713                        out.insert("disableDoubleEncoding".to_string(), true.into());
4714                        out
4715                    })]
4716                )
4717                .build()
4718        );
4719    }
4720
4721    /// vanilla path style@cn-north-1
4722    #[test]
4723    fn test_170() {
4724        let params = crate::config::endpoint::Params::builder()
4725            .accelerate(false)
4726            .bucket("bucket-name".to_string())
4727            .force_path_style(true)
4728            .region("cn-north-1".to_string())
4729            .use_dual_stack(false)
4730            .use_fips(false)
4731            .build()
4732            .expect("invalid params");
4733        let resolver = crate::config::endpoint::DefaultResolver::new();
4734        let endpoint = resolver.resolve_endpoint(&params);
4735        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/bucket-name");
4736        assert_eq!(
4737            endpoint,
4738            ::aws_smithy_types::endpoint::Endpoint::builder()
4739                .url("https://s3.cn-north-1.amazonaws.com.cn/bucket-name")
4740                .property(
4741                    "authSchemes",
4742                    vec![::aws_smithy_types::Document::from({
4743                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4744                        out.insert("name".to_string(), "sigv4".to_string().into());
4745                        out.insert("signingName".to_string(), "s3".to_string().into());
4746                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4747                        out.insert("disableDoubleEncoding".to_string(), true.into());
4748                        out
4749                    })]
4750                )
4751                .build()
4752        );
4753    }
4754
4755    /// path style + fips@cn-north-1
4756    #[test]
4757    fn test_171() {
4758        let params = crate::config::endpoint::Params::builder()
4759            .accelerate(false)
4760            .bucket("bucket-name".to_string())
4761            .force_path_style(true)
4762            .region("cn-north-1".to_string())
4763            .use_dual_stack(false)
4764            .use_fips(true)
4765            .build()
4766            .expect("invalid params");
4767        let resolver = crate::config::endpoint::DefaultResolver::new();
4768        let endpoint = resolver.resolve_endpoint(&params);
4769        let error = endpoint.expect_err("expected error: Partition does not support FIPS [path style + fips@cn-north-1]");
4770        assert_eq!(format!("{}", error), "Partition does not support FIPS")
4771    }
4772
4773    /// path style + accelerate = error@cn-north-1
4774    #[test]
4775    fn test_172() {
4776        let params = crate::config::endpoint::Params::builder()
4777            .accelerate(true)
4778            .bucket("bucket-name".to_string())
4779            .force_path_style(true)
4780            .region("cn-north-1".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 = endpoint
4788            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@cn-north-1]");
4789        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
4790    }
4791
4792    /// path style + dualstack@cn-north-1
4793    #[test]
4794    fn test_173() {
4795        let params = crate::config::endpoint::Params::builder()
4796            .accelerate(false)
4797            .bucket("bucket-name".to_string())
4798            .force_path_style(true)
4799            .region("cn-north-1".to_string())
4800            .use_dual_stack(true)
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.dualstack.cn-north-1.amazonaws.com.cn/bucket-name");
4807        assert_eq!(
4808            endpoint,
4809            ::aws_smithy_types::endpoint::Endpoint::builder()
4810                .url("https://s3.dualstack.cn-north-1.amazonaws.com.cn/bucket-name")
4811                .property(
4812                    "authSchemes",
4813                    vec![::aws_smithy_types::Document::from({
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(), "cn-north-1".to_string().into());
4818                        out.insert("disableDoubleEncoding".to_string(), true.into());
4819                        out
4820                    })]
4821                )
4822                .build()
4823        );
4824    }
4825
4826    /// path style + arn is error@cn-north-1
4827    #[test]
4828    fn test_174() {
4829        let params = crate::config::endpoint::Params::builder()
4830            .accelerate(false)
4831            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
4832            .force_path_style(true)
4833            .region("cn-north-1".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 error =
4841            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@cn-north-1]");
4842        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
4843    }
4844
4845    /// path style + invalid DNS name@cn-north-1
4846    #[test]
4847    fn test_175() {
4848        let params = crate::config::endpoint::Params::builder()
4849            .accelerate(false)
4850            .bucket("99a_b".to_string())
4851            .force_path_style(true)
4852            .region("cn-north-1".to_string())
4853            .use_dual_stack(false)
4854            .use_fips(false)
4855            .build()
4856            .expect("invalid params");
4857        let resolver = crate::config::endpoint::DefaultResolver::new();
4858        let endpoint = resolver.resolve_endpoint(&params);
4859        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/99a_b");
4860        assert_eq!(
4861            endpoint,
4862            ::aws_smithy_types::endpoint::Endpoint::builder()
4863                .url("https://s3.cn-north-1.amazonaws.com.cn/99a_b")
4864                .property(
4865                    "authSchemes",
4866                    vec![::aws_smithy_types::Document::from({
4867                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4868                        out.insert("name".to_string(), "sigv4".to_string().into());
4869                        out.insert("signingName".to_string(), "s3".to_string().into());
4870                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4871                        out.insert("disableDoubleEncoding".to_string(), true.into());
4872                        out
4873                    })]
4874                )
4875                .build()
4876        );
4877    }
4878
4879    /// no path style + invalid DNS name@cn-north-1
4880    #[test]
4881    fn test_176() {
4882        let params = crate::config::endpoint::Params::builder()
4883            .accelerate(false)
4884            .bucket("99a_b".to_string())
4885            .region("cn-north-1".to_string())
4886            .use_dual_stack(false)
4887            .use_fips(false)
4888            .build()
4889            .expect("invalid params");
4890        let resolver = crate::config::endpoint::DefaultResolver::new();
4891        let endpoint = resolver.resolve_endpoint(&params);
4892        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/99a_b");
4893        assert_eq!(
4894            endpoint,
4895            ::aws_smithy_types::endpoint::Endpoint::builder()
4896                .url("https://s3.cn-north-1.amazonaws.com.cn/99a_b")
4897                .property(
4898                    "authSchemes",
4899                    vec![::aws_smithy_types::Document::from({
4900                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4901                        out.insert("name".to_string(), "sigv4".to_string().into());
4902                        out.insert("signingName".to_string(), "s3".to_string().into());
4903                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4904                        out.insert("disableDoubleEncoding".to_string(), true.into());
4905                        out
4906                    })]
4907                )
4908                .build()
4909        );
4910    }
4911
4912    /// vanilla path style@af-south-1
4913    #[test]
4914    fn test_177() {
4915        let params = crate::config::endpoint::Params::builder()
4916            .accelerate(false)
4917            .bucket("bucket-name".to_string())
4918            .force_path_style(true)
4919            .region("af-south-1".to_string())
4920            .use_dual_stack(false)
4921            .use_fips(false)
4922            .build()
4923            .expect("invalid params");
4924        let resolver = crate::config::endpoint::DefaultResolver::new();
4925        let endpoint = resolver.resolve_endpoint(&params);
4926        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/bucket-name");
4927        assert_eq!(
4928            endpoint,
4929            ::aws_smithy_types::endpoint::Endpoint::builder()
4930                .url("https://s3.af-south-1.amazonaws.com/bucket-name")
4931                .property(
4932                    "authSchemes",
4933                    vec![::aws_smithy_types::Document::from({
4934                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4935                        out.insert("name".to_string(), "sigv4".to_string().into());
4936                        out.insert("signingName".to_string(), "s3".to_string().into());
4937                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4938                        out.insert("disableDoubleEncoding".to_string(), true.into());
4939                        out
4940                    })]
4941                )
4942                .build()
4943        );
4944    }
4945
4946    /// path style + fips@af-south-1
4947    #[test]
4948    fn test_178() {
4949        let params = crate::config::endpoint::Params::builder()
4950            .accelerate(false)
4951            .bucket("bucket-name".to_string())
4952            .force_path_style(true)
4953            .region("af-south-1".to_string())
4954            .use_dual_stack(false)
4955            .use_fips(true)
4956            .build()
4957            .expect("invalid params");
4958        let resolver = crate::config::endpoint::DefaultResolver::new();
4959        let endpoint = resolver.resolve_endpoint(&params);
4960        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.af-south-1.amazonaws.com/bucket-name");
4961        assert_eq!(
4962            endpoint,
4963            ::aws_smithy_types::endpoint::Endpoint::builder()
4964                .url("https://s3-fips.af-south-1.amazonaws.com/bucket-name")
4965                .property(
4966                    "authSchemes",
4967                    vec![::aws_smithy_types::Document::from({
4968                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4969                        out.insert("signingName".to_string(), "s3".to_string().into());
4970                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4971                        out.insert("disableDoubleEncoding".to_string(), true.into());
4972                        out.insert("name".to_string(), "sigv4".to_string().into());
4973                        out
4974                    })]
4975                )
4976                .build()
4977        );
4978    }
4979
4980    /// path style + accelerate = error@af-south-1
4981    #[test]
4982    fn test_179() {
4983        let params = crate::config::endpoint::Params::builder()
4984            .accelerate(true)
4985            .bucket("bucket-name".to_string())
4986            .force_path_style(true)
4987            .region("af-south-1".to_string())
4988            .use_dual_stack(false)
4989            .use_fips(false)
4990            .build()
4991            .expect("invalid params");
4992        let resolver = crate::config::endpoint::DefaultResolver::new();
4993        let endpoint = resolver.resolve_endpoint(&params);
4994        let error = endpoint
4995            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@af-south-1]");
4996        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
4997    }
4998
4999    /// path style + dualstack@af-south-1
5000    #[test]
5001    fn test_180() {
5002        let params = crate::config::endpoint::Params::builder()
5003            .accelerate(false)
5004            .bucket("bucket-name".to_string())
5005            .force_path_style(true)
5006            .region("af-south-1".to_string())
5007            .use_dual_stack(true)
5008            .use_fips(false)
5009            .build()
5010            .expect("invalid params");
5011        let resolver = crate::config::endpoint::DefaultResolver::new();
5012        let endpoint = resolver.resolve_endpoint(&params);
5013        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.af-south-1.amazonaws.com/bucket-name");
5014        assert_eq!(
5015            endpoint,
5016            ::aws_smithy_types::endpoint::Endpoint::builder()
5017                .url("https://s3.dualstack.af-south-1.amazonaws.com/bucket-name")
5018                .property(
5019                    "authSchemes",
5020                    vec![::aws_smithy_types::Document::from({
5021                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5022                        out.insert("name".to_string(), "sigv4".to_string().into());
5023                        out.insert("signingName".to_string(), "s3".to_string().into());
5024                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5025                        out.insert("disableDoubleEncoding".to_string(), true.into());
5026                        out
5027                    })]
5028                )
5029                .build()
5030        );
5031    }
5032
5033    /// path style + arn is error@af-south-1
5034    #[test]
5035    fn test_181() {
5036        let params = crate::config::endpoint::Params::builder()
5037            .accelerate(false)
5038            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
5039            .force_path_style(true)
5040            .region("af-south-1".to_string())
5041            .use_dual_stack(false)
5042            .use_fips(false)
5043            .build()
5044            .expect("invalid params");
5045        let resolver = crate::config::endpoint::DefaultResolver::new();
5046        let endpoint = resolver.resolve_endpoint(&params);
5047        let error =
5048            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@af-south-1]");
5049        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
5050    }
5051
5052    /// path style + invalid DNS name@af-south-1
5053    #[test]
5054    fn test_182() {
5055        let params = crate::config::endpoint::Params::builder()
5056            .accelerate(false)
5057            .bucket("99a_b".to_string())
5058            .force_path_style(true)
5059            .region("af-south-1".to_string())
5060            .use_dual_stack(false)
5061            .use_fips(false)
5062            .build()
5063            .expect("invalid params");
5064        let resolver = crate::config::endpoint::DefaultResolver::new();
5065        let endpoint = resolver.resolve_endpoint(&params);
5066        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/99a_b");
5067        assert_eq!(
5068            endpoint,
5069            ::aws_smithy_types::endpoint::Endpoint::builder()
5070                .url("https://s3.af-south-1.amazonaws.com/99a_b")
5071                .property(
5072                    "authSchemes",
5073                    vec![::aws_smithy_types::Document::from({
5074                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5075                        out.insert("name".to_string(), "sigv4".to_string().into());
5076                        out.insert("signingName".to_string(), "s3".to_string().into());
5077                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5078                        out.insert("disableDoubleEncoding".to_string(), true.into());
5079                        out
5080                    })]
5081                )
5082                .build()
5083        );
5084    }
5085
5086    /// no path style + invalid DNS name@af-south-1
5087    #[test]
5088    fn test_183() {
5089        let params = crate::config::endpoint::Params::builder()
5090            .accelerate(false)
5091            .bucket("99a_b".to_string())
5092            .region("af-south-1".to_string())
5093            .use_dual_stack(false)
5094            .use_fips(false)
5095            .build()
5096            .expect("invalid params");
5097        let resolver = crate::config::endpoint::DefaultResolver::new();
5098        let endpoint = resolver.resolve_endpoint(&params);
5099        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/99a_b");
5100        assert_eq!(
5101            endpoint,
5102            ::aws_smithy_types::endpoint::Endpoint::builder()
5103                .url("https://s3.af-south-1.amazonaws.com/99a_b")
5104                .property(
5105                    "authSchemes",
5106                    vec![::aws_smithy_types::Document::from({
5107                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5108                        out.insert("name".to_string(), "sigv4".to_string().into());
5109                        out.insert("signingName".to_string(), "s3".to_string().into());
5110                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5111                        out.insert("disableDoubleEncoding".to_string(), true.into());
5112                        out
5113                    })]
5114                )
5115                .build()
5116        );
5117    }
5118
5119    /// virtual addressing + private link@us-west-2
5120    #[test]
5121    fn test_184() {
5122        let params = crate::config::endpoint::Params::builder()
5123            .accelerate(false)
5124            .bucket("bucket-name".to_string())
5125            .force_path_style(false)
5126            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5127            .region("us-west-2".to_string())
5128            .use_dual_stack(false)
5129            .use_fips(false)
5130            .build()
5131            .expect("invalid params");
5132        let resolver = crate::config::endpoint::DefaultResolver::new();
5133        let endpoint = resolver.resolve_endpoint(&params);
5134        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
5135        assert_eq!(
5136            endpoint,
5137            ::aws_smithy_types::endpoint::Endpoint::builder()
5138                .url("http://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
5139                .property(
5140                    "authSchemes",
5141                    vec![::aws_smithy_types::Document::from({
5142                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5143                        out.insert("name".to_string(), "sigv4".to_string().into());
5144                        out.insert("signingName".to_string(), "s3".to_string().into());
5145                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5146                        out.insert("disableDoubleEncoding".to_string(), true.into());
5147                        out
5148                    })]
5149                )
5150                .build()
5151        );
5152    }
5153
5154    /// path style + private link@us-west-2
5155    #[test]
5156    fn test_185() {
5157        let params = crate::config::endpoint::Params::builder()
5158            .accelerate(false)
5159            .bucket("bucket-name".to_string())
5160            .force_path_style(true)
5161            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5162            .region("us-west-2".to_string())
5163            .use_dual_stack(false)
5164            .use_fips(false)
5165            .build()
5166            .expect("invalid params");
5167        let resolver = crate::config::endpoint::DefaultResolver::new();
5168        let endpoint = resolver.resolve_endpoint(&params);
5169        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
5170        assert_eq!(
5171            endpoint,
5172            ::aws_smithy_types::endpoint::Endpoint::builder()
5173                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
5174                .property(
5175                    "authSchemes",
5176                    vec![::aws_smithy_types::Document::from({
5177                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5178                        out.insert("name".to_string(), "sigv4".to_string().into());
5179                        out.insert("signingName".to_string(), "s3".to_string().into());
5180                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5181                        out.insert("disableDoubleEncoding".to_string(), true.into());
5182                        out
5183                    })]
5184                )
5185                .build()
5186        );
5187    }
5188
5189    /// SDK::Host + FIPS@us-west-2
5190    #[test]
5191    fn test_186() {
5192        let params = crate::config::endpoint::Params::builder()
5193            .accelerate(false)
5194            .bucket("bucket-name".to_string())
5195            .force_path_style(false)
5196            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5197            .region("us-west-2".to_string())
5198            .use_dual_stack(false)
5199            .use_fips(true)
5200            .build()
5201            .expect("invalid params");
5202        let resolver = crate::config::endpoint::DefaultResolver::new();
5203        let endpoint = resolver.resolve_endpoint(&params);
5204        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [SDK::Host + FIPS@us-west-2]");
5205        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
5206    }
5207
5208    /// SDK::Host + DualStack@us-west-2
5209    #[test]
5210    fn test_187() {
5211        let params = crate::config::endpoint::Params::builder()
5212            .accelerate(false)
5213            .bucket("bucket-name".to_string())
5214            .force_path_style(false)
5215            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5216            .region("us-west-2".to_string())
5217            .use_dual_stack(true)
5218            .use_fips(false)
5219            .build()
5220            .expect("invalid params");
5221        let resolver = crate::config::endpoint::DefaultResolver::new();
5222        let endpoint = resolver.resolve_endpoint(&params);
5223        let error =
5224            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@us-west-2]");
5225        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
5226    }
5227
5228    /// SDK::HOST + accelerate@us-west-2
5229    #[test]
5230    fn test_188() {
5231        let params = crate::config::endpoint::Params::builder()
5232            .accelerate(true)
5233            .bucket("bucket-name".to_string())
5234            .force_path_style(false)
5235            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5236            .region("us-west-2".to_string())
5237            .use_dual_stack(false)
5238            .use_fips(false)
5239            .build()
5240            .expect("invalid params");
5241        let resolver = crate::config::endpoint::DefaultResolver::new();
5242        let endpoint = resolver.resolve_endpoint(&params);
5243        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@us-west-2]");
5244        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
5245    }
5246
5247    /// SDK::Host + access point ARN@us-west-2
5248    #[test]
5249    fn test_189() {
5250        let params = crate::config::endpoint::Params::builder()
5251            .accelerate(false)
5252            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5253            .force_path_style(false)
5254            .endpoint("https://beta.example.com".to_string())
5255            .region("us-west-2".to_string())
5256            .use_dual_stack(false)
5257            .use_fips(false)
5258            .build()
5259            .expect("invalid params");
5260        let resolver = crate::config::endpoint::DefaultResolver::new();
5261        let endpoint = resolver.resolve_endpoint(&params);
5262        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
5263        assert_eq!(
5264            endpoint,
5265            ::aws_smithy_types::endpoint::Endpoint::builder()
5266                .url("https://myendpoint-123456789012.beta.example.com")
5267                .property(
5268                    "authSchemes",
5269                    vec![::aws_smithy_types::Document::from({
5270                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5271                        out.insert("name".to_string(), "sigv4".to_string().into());
5272                        out.insert("signingName".to_string(), "s3".to_string().into());
5273                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5274                        out.insert("disableDoubleEncoding".to_string(), true.into());
5275                        out
5276                    })]
5277                )
5278                .build()
5279        );
5280    }
5281
5282    /// virtual addressing + private link@cn-north-1
5283    #[test]
5284    fn test_190() {
5285        let params = crate::config::endpoint::Params::builder()
5286            .accelerate(false)
5287            .bucket("bucket-name".to_string())
5288            .force_path_style(false)
5289            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5290            .region("cn-north-1".to_string())
5291            .use_dual_stack(false)
5292            .use_fips(false)
5293            .build()
5294            .expect("invalid params");
5295        let resolver = crate::config::endpoint::DefaultResolver::new();
5296        let endpoint = resolver.resolve_endpoint(&params);
5297        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
5298        assert_eq!(
5299            endpoint,
5300            ::aws_smithy_types::endpoint::Endpoint::builder()
5301                .url("https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
5302                .property(
5303                    "authSchemes",
5304                    vec![::aws_smithy_types::Document::from({
5305                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5306                        out.insert("name".to_string(), "sigv4".to_string().into());
5307                        out.insert("signingName".to_string(), "s3".to_string().into());
5308                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5309                        out.insert("disableDoubleEncoding".to_string(), true.into());
5310                        out
5311                    })]
5312                )
5313                .build()
5314        );
5315    }
5316
5317    /// path style + private link@cn-north-1
5318    #[test]
5319    fn test_191() {
5320        let params = crate::config::endpoint::Params::builder()
5321            .accelerate(false)
5322            .bucket("bucket-name".to_string())
5323            .force_path_style(true)
5324            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5325            .region("cn-north-1".to_string())
5326            .use_dual_stack(false)
5327            .use_fips(false)
5328            .build()
5329            .expect("invalid params");
5330        let resolver = crate::config::endpoint::DefaultResolver::new();
5331        let endpoint = resolver.resolve_endpoint(&params);
5332        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
5333        assert_eq!(
5334            endpoint,
5335            ::aws_smithy_types::endpoint::Endpoint::builder()
5336                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
5337                .property(
5338                    "authSchemes",
5339                    vec![::aws_smithy_types::Document::from({
5340                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5341                        out.insert("name".to_string(), "sigv4".to_string().into());
5342                        out.insert("signingName".to_string(), "s3".to_string().into());
5343                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5344                        out.insert("disableDoubleEncoding".to_string(), true.into());
5345                        out
5346                    })]
5347                )
5348                .build()
5349        );
5350    }
5351
5352    /// FIPS@cn-north-1
5353    #[test]
5354    fn test_192() {
5355        let params = crate::config::endpoint::Params::builder()
5356            .accelerate(false)
5357            .bucket("bucket-name".to_string())
5358            .force_path_style(false)
5359            .region("cn-north-1".to_string())
5360            .use_dual_stack(false)
5361            .use_fips(true)
5362            .build()
5363            .expect("invalid params");
5364        let resolver = crate::config::endpoint::DefaultResolver::new();
5365        let endpoint = resolver.resolve_endpoint(&params);
5366        let error = endpoint.expect_err("expected error: Partition does not support FIPS [FIPS@cn-north-1]");
5367        assert_eq!(format!("{}", error), "Partition does not support FIPS")
5368    }
5369
5370    /// SDK::Host + DualStack@cn-north-1
5371    #[test]
5372    fn test_193() {
5373        let params = crate::config::endpoint::Params::builder()
5374            .accelerate(false)
5375            .bucket("bucket-name".to_string())
5376            .force_path_style(false)
5377            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5378            .region("cn-north-1".to_string())
5379            .use_dual_stack(true)
5380            .use_fips(false)
5381            .build()
5382            .expect("invalid params");
5383        let resolver = crate::config::endpoint::DefaultResolver::new();
5384        let endpoint = resolver.resolve_endpoint(&params);
5385        let error =
5386            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@cn-north-1]");
5387        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
5388    }
5389
5390    /// SDK::HOST + accelerate@cn-north-1
5391    #[test]
5392    fn test_194() {
5393        let params = crate::config::endpoint::Params::builder()
5394            .accelerate(true)
5395            .bucket("bucket-name".to_string())
5396            .force_path_style(false)
5397            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5398            .region("cn-north-1".to_string())
5399            .use_dual_stack(false)
5400            .use_fips(false)
5401            .build()
5402            .expect("invalid params");
5403        let resolver = crate::config::endpoint::DefaultResolver::new();
5404        let endpoint = resolver.resolve_endpoint(&params);
5405        let error =
5406            endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@cn-north-1]");
5407        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
5408    }
5409
5410    /// SDK::Host + access point ARN@cn-north-1
5411    #[test]
5412    fn test_195() {
5413        let params = crate::config::endpoint::Params::builder()
5414            .accelerate(false)
5415            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5416            .force_path_style(false)
5417            .endpoint("https://beta.example.com".to_string())
5418            .region("cn-north-1".to_string())
5419            .use_dual_stack(false)
5420            .use_fips(false)
5421            .build()
5422            .expect("invalid params");
5423        let resolver = crate::config::endpoint::DefaultResolver::new();
5424        let endpoint = resolver.resolve_endpoint(&params);
5425        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
5426        assert_eq!(
5427            endpoint,
5428            ::aws_smithy_types::endpoint::Endpoint::builder()
5429                .url("https://myendpoint-123456789012.beta.example.com")
5430                .property(
5431                    "authSchemes",
5432                    vec![::aws_smithy_types::Document::from({
5433                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5434                        out.insert("name".to_string(), "sigv4".to_string().into());
5435                        out.insert("signingName".to_string(), "s3".to_string().into());
5436                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5437                        out.insert("disableDoubleEncoding".to_string(), true.into());
5438                        out
5439                    })]
5440                )
5441                .build()
5442        );
5443    }
5444
5445    /// virtual addressing + private link@af-south-1
5446    #[test]
5447    fn test_196() {
5448        let params = crate::config::endpoint::Params::builder()
5449            .accelerate(false)
5450            .bucket("bucket-name".to_string())
5451            .force_path_style(false)
5452            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5453            .region("af-south-1".to_string())
5454            .use_dual_stack(false)
5455            .use_fips(false)
5456            .build()
5457            .expect("invalid params");
5458        let resolver = crate::config::endpoint::DefaultResolver::new();
5459        let endpoint = resolver.resolve_endpoint(&params);
5460        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
5461        assert_eq!(
5462            endpoint,
5463            ::aws_smithy_types::endpoint::Endpoint::builder()
5464                .url("https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
5465                .property(
5466                    "authSchemes",
5467                    vec![::aws_smithy_types::Document::from({
5468                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5469                        out.insert("name".to_string(), "sigv4".to_string().into());
5470                        out.insert("signingName".to_string(), "s3".to_string().into());
5471                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5472                        out.insert("disableDoubleEncoding".to_string(), true.into());
5473                        out
5474                    })]
5475                )
5476                .build()
5477        );
5478    }
5479
5480    /// path style + private link@af-south-1
5481    #[test]
5482    fn test_197() {
5483        let params = crate::config::endpoint::Params::builder()
5484            .accelerate(false)
5485            .bucket("bucket-name".to_string())
5486            .force_path_style(true)
5487            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5488            .region("af-south-1".to_string())
5489            .use_dual_stack(false)
5490            .use_fips(false)
5491            .build()
5492            .expect("invalid params");
5493        let resolver = crate::config::endpoint::DefaultResolver::new();
5494        let endpoint = resolver.resolve_endpoint(&params);
5495        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
5496        assert_eq!(
5497            endpoint,
5498            ::aws_smithy_types::endpoint::Endpoint::builder()
5499                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
5500                .property(
5501                    "authSchemes",
5502                    vec![::aws_smithy_types::Document::from({
5503                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5504                        out.insert("name".to_string(), "sigv4".to_string().into());
5505                        out.insert("signingName".to_string(), "s3".to_string().into());
5506                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5507                        out.insert("disableDoubleEncoding".to_string(), true.into());
5508                        out
5509                    })]
5510                )
5511                .build()
5512        );
5513    }
5514
5515    /// SDK::Host + FIPS@af-south-1
5516    #[test]
5517    fn test_198() {
5518        let params = crate::config::endpoint::Params::builder()
5519            .accelerate(false)
5520            .bucket("bucket-name".to_string())
5521            .force_path_style(false)
5522            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5523            .region("af-south-1".to_string())
5524            .use_dual_stack(false)
5525            .use_fips(true)
5526            .build()
5527            .expect("invalid params");
5528        let resolver = crate::config::endpoint::DefaultResolver::new();
5529        let endpoint = resolver.resolve_endpoint(&params);
5530        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [SDK::Host + FIPS@af-south-1]");
5531        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
5532    }
5533
5534    /// SDK::Host + DualStack@af-south-1
5535    #[test]
5536    fn test_199() {
5537        let params = crate::config::endpoint::Params::builder()
5538            .accelerate(false)
5539            .bucket("bucket-name".to_string())
5540            .force_path_style(false)
5541            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5542            .region("af-south-1".to_string())
5543            .use_dual_stack(true)
5544            .use_fips(false)
5545            .build()
5546            .expect("invalid params");
5547        let resolver = crate::config::endpoint::DefaultResolver::new();
5548        let endpoint = resolver.resolve_endpoint(&params);
5549        let error =
5550            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@af-south-1]");
5551        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
5552    }
5553
5554    /// SDK::HOST + accelerate@af-south-1
5555    #[test]
5556    fn test_200() {
5557        let params = crate::config::endpoint::Params::builder()
5558            .accelerate(true)
5559            .bucket("bucket-name".to_string())
5560            .force_path_style(false)
5561            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5562            .region("af-south-1".to_string())
5563            .use_dual_stack(false)
5564            .use_fips(false)
5565            .build()
5566            .expect("invalid params");
5567        let resolver = crate::config::endpoint::DefaultResolver::new();
5568        let endpoint = resolver.resolve_endpoint(&params);
5569        let error =
5570            endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@af-south-1]");
5571        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
5572    }
5573
5574    /// SDK::Host + access point ARN@af-south-1
5575    #[test]
5576    fn test_201() {
5577        let params = crate::config::endpoint::Params::builder()
5578            .accelerate(false)
5579            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5580            .force_path_style(false)
5581            .endpoint("https://beta.example.com".to_string())
5582            .region("af-south-1".to_string())
5583            .use_dual_stack(false)
5584            .use_fips(false)
5585            .build()
5586            .expect("invalid params");
5587        let resolver = crate::config::endpoint::DefaultResolver::new();
5588        let endpoint = resolver.resolve_endpoint(&params);
5589        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
5590        assert_eq!(
5591            endpoint,
5592            ::aws_smithy_types::endpoint::Endpoint::builder()
5593                .url("https://myendpoint-123456789012.beta.example.com")
5594                .property(
5595                    "authSchemes",
5596                    vec![::aws_smithy_types::Document::from({
5597                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5598                        out.insert("name".to_string(), "sigv4".to_string().into());
5599                        out.insert("signingName".to_string(), "s3".to_string().into());
5600                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5601                        out.insert("disableDoubleEncoding".to_string(), true.into());
5602                        out
5603                    })]
5604                )
5605                .build()
5606        );
5607    }
5608
5609    /// vanilla access point arn@us-west-2
5610    #[test]
5611    fn test_202() {
5612        let params = crate::config::endpoint::Params::builder()
5613            .accelerate(false)
5614            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5615            .force_path_style(false)
5616            .region("us-west-2".to_string())
5617            .use_dual_stack(false)
5618            .use_fips(false)
5619            .build()
5620            .expect("invalid params");
5621        let resolver = crate::config::endpoint::DefaultResolver::new();
5622        let endpoint = resolver.resolve_endpoint(&params);
5623        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
5624        assert_eq!(
5625            endpoint,
5626            ::aws_smithy_types::endpoint::Endpoint::builder()
5627                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
5628                .property(
5629                    "authSchemes",
5630                    vec![::aws_smithy_types::Document::from({
5631                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5632                        out.insert("name".to_string(), "sigv4".to_string().into());
5633                        out.insert("signingName".to_string(), "s3".to_string().into());
5634                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5635                        out.insert("disableDoubleEncoding".to_string(), true.into());
5636                        out
5637                    })]
5638                )
5639                .build()
5640        );
5641    }
5642
5643    /// access point arn + FIPS@us-west-2
5644    #[test]
5645    fn test_203() {
5646        let params = crate::config::endpoint::Params::builder()
5647            .accelerate(false)
5648            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5649            .force_path_style(false)
5650            .region("us-west-2".to_string())
5651            .use_dual_stack(false)
5652            .use_fips(true)
5653            .build()
5654            .expect("invalid params");
5655        let resolver = crate::config::endpoint::DefaultResolver::new();
5656        let endpoint = resolver.resolve_endpoint(&params);
5657        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.us-west-2.amazonaws.com");
5658        assert_eq!(
5659            endpoint,
5660            ::aws_smithy_types::endpoint::Endpoint::builder()
5661                .url("https://myendpoint-123456789012.s3-accesspoint-fips.us-west-2.amazonaws.com")
5662                .property(
5663                    "authSchemes",
5664                    vec![::aws_smithy_types::Document::from({
5665                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5666                        out.insert("name".to_string(), "sigv4".to_string().into());
5667                        out.insert("signingName".to_string(), "s3".to_string().into());
5668                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5669                        out.insert("disableDoubleEncoding".to_string(), true.into());
5670                        out
5671                    })]
5672                )
5673                .build()
5674        );
5675    }
5676
5677    /// access point arn + accelerate = error@us-west-2
5678    #[test]
5679    fn test_204() {
5680        let params = crate::config::endpoint::Params::builder()
5681            .accelerate(true)
5682            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5683            .force_path_style(false)
5684            .region("us-west-2".to_string())
5685            .use_dual_stack(false)
5686            .use_fips(false)
5687            .build()
5688            .expect("invalid params");
5689        let resolver = crate::config::endpoint::DefaultResolver::new();
5690        let endpoint = resolver.resolve_endpoint(&params);
5691        let error =
5692            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@us-west-2]");
5693        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
5694    }
5695
5696    /// access point arn + FIPS + DualStack@us-west-2
5697    #[test]
5698    fn test_205() {
5699        let params = crate::config::endpoint::Params::builder()
5700            .accelerate(false)
5701            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5702            .force_path_style(false)
5703            .region("us-west-2".to_string())
5704            .use_dual_stack(true)
5705            .use_fips(true)
5706            .build()
5707            .expect("invalid params");
5708        let resolver = crate::config::endpoint::DefaultResolver::new();
5709        let endpoint = resolver.resolve_endpoint(&params);
5710        let endpoint =
5711            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com");
5712        assert_eq!(
5713            endpoint,
5714            ::aws_smithy_types::endpoint::Endpoint::builder()
5715                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com")
5716                .property(
5717                    "authSchemes",
5718                    vec![::aws_smithy_types::Document::from({
5719                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5720                        out.insert("name".to_string(), "sigv4".to_string().into());
5721                        out.insert("signingName".to_string(), "s3".to_string().into());
5722                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5723                        out.insert("disableDoubleEncoding".to_string(), true.into());
5724                        out
5725                    })]
5726                )
5727                .build()
5728        );
5729    }
5730
5731    /// vanilla access point arn@cn-north-1
5732    #[test]
5733    fn test_206() {
5734        let params = crate::config::endpoint::Params::builder()
5735            .accelerate(false)
5736            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5737            .force_path_style(false)
5738            .region("cn-north-1".to_string())
5739            .use_dual_stack(false)
5740            .use_fips(false)
5741            .build()
5742            .expect("invalid params");
5743        let resolver = crate::config::endpoint::DefaultResolver::new();
5744        let endpoint = resolver.resolve_endpoint(&params);
5745        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.cn-north-1.amazonaws.com.cn");
5746        assert_eq!(
5747            endpoint,
5748            ::aws_smithy_types::endpoint::Endpoint::builder()
5749                .url("https://myendpoint-123456789012.s3-accesspoint.cn-north-1.amazonaws.com.cn")
5750                .property(
5751                    "authSchemes",
5752                    vec![::aws_smithy_types::Document::from({
5753                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5754                        out.insert("name".to_string(), "sigv4".to_string().into());
5755                        out.insert("signingName".to_string(), "s3".to_string().into());
5756                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5757                        out.insert("disableDoubleEncoding".to_string(), true.into());
5758                        out
5759                    })]
5760                )
5761                .build()
5762        );
5763    }
5764
5765    /// access point arn + FIPS@cn-north-1
5766    #[test]
5767    fn test_207() {
5768        let params = crate::config::endpoint::Params::builder()
5769            .accelerate(false)
5770            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5771            .force_path_style(false)
5772            .region("cn-north-1".to_string())
5773            .use_dual_stack(false)
5774            .use_fips(true)
5775            .build()
5776            .expect("invalid params");
5777        let resolver = crate::config::endpoint::DefaultResolver::new();
5778        let endpoint = resolver.resolve_endpoint(&params);
5779        let error = endpoint.expect_err("expected error: Partition does not support FIPS [access point arn + FIPS@cn-north-1]");
5780        assert_eq!(format!("{}", error), "Partition does not support FIPS")
5781    }
5782
5783    /// access point arn + accelerate = error@cn-north-1
5784    #[test]
5785    fn test_208() {
5786        let params = crate::config::endpoint::Params::builder()
5787            .accelerate(true)
5788            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5789            .force_path_style(false)
5790            .region("cn-north-1".to_string())
5791            .use_dual_stack(false)
5792            .use_fips(false)
5793            .build()
5794            .expect("invalid params");
5795        let resolver = crate::config::endpoint::DefaultResolver::new();
5796        let endpoint = resolver.resolve_endpoint(&params);
5797        let error =
5798            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@cn-north-1]");
5799        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
5800    }
5801
5802    /// access point arn + FIPS + DualStack@cn-north-1
5803    #[test]
5804    fn test_209() {
5805        let params = crate::config::endpoint::Params::builder()
5806            .accelerate(false)
5807            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5808            .force_path_style(false)
5809            .region("cn-north-1".to_string())
5810            .use_dual_stack(true)
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 error = endpoint.expect_err("expected error: Partition does not support FIPS [access point arn + FIPS + DualStack@cn-north-1]");
5817        assert_eq!(format!("{}", error), "Partition does not support FIPS")
5818    }
5819
5820    /// vanilla access point arn@af-south-1
5821    #[test]
5822    fn test_210() {
5823        let params = crate::config::endpoint::Params::builder()
5824            .accelerate(false)
5825            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5826            .force_path_style(false)
5827            .region("af-south-1".to_string())
5828            .use_dual_stack(false)
5829            .use_fips(false)
5830            .build()
5831            .expect("invalid params");
5832        let resolver = crate::config::endpoint::DefaultResolver::new();
5833        let endpoint = resolver.resolve_endpoint(&params);
5834        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.af-south-1.amazonaws.com");
5835        assert_eq!(
5836            endpoint,
5837            ::aws_smithy_types::endpoint::Endpoint::builder()
5838                .url("https://myendpoint-123456789012.s3-accesspoint.af-south-1.amazonaws.com")
5839                .property(
5840                    "authSchemes",
5841                    vec![::aws_smithy_types::Document::from({
5842                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5843                        out.insert("name".to_string(), "sigv4".to_string().into());
5844                        out.insert("signingName".to_string(), "s3".to_string().into());
5845                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5846                        out.insert("disableDoubleEncoding".to_string(), true.into());
5847                        out
5848                    })]
5849                )
5850                .build()
5851        );
5852    }
5853
5854    /// access point arn + FIPS@af-south-1
5855    #[test]
5856    fn test_211() {
5857        let params = crate::config::endpoint::Params::builder()
5858            .accelerate(false)
5859            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5860            .force_path_style(false)
5861            .region("af-south-1".to_string())
5862            .use_dual_stack(false)
5863            .use_fips(true)
5864            .build()
5865            .expect("invalid params");
5866        let resolver = crate::config::endpoint::DefaultResolver::new();
5867        let endpoint = resolver.resolve_endpoint(&params);
5868        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.af-south-1.amazonaws.com");
5869        assert_eq!(
5870            endpoint,
5871            ::aws_smithy_types::endpoint::Endpoint::builder()
5872                .url("https://myendpoint-123456789012.s3-accesspoint-fips.af-south-1.amazonaws.com")
5873                .property(
5874                    "authSchemes",
5875                    vec![::aws_smithy_types::Document::from({
5876                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5877                        out.insert("name".to_string(), "sigv4".to_string().into());
5878                        out.insert("signingName".to_string(), "s3".to_string().into());
5879                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5880                        out.insert("disableDoubleEncoding".to_string(), true.into());
5881                        out
5882                    })]
5883                )
5884                .build()
5885        );
5886    }
5887
5888    /// access point arn + accelerate = error@af-south-1
5889    #[test]
5890    fn test_212() {
5891        let params = crate::config::endpoint::Params::builder()
5892            .accelerate(true)
5893            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5894            .force_path_style(false)
5895            .region("af-south-1".to_string())
5896            .use_dual_stack(false)
5897            .use_fips(false)
5898            .build()
5899            .expect("invalid params");
5900        let resolver = crate::config::endpoint::DefaultResolver::new();
5901        let endpoint = resolver.resolve_endpoint(&params);
5902        let error =
5903            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@af-south-1]");
5904        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
5905    }
5906
5907    /// access point arn + FIPS + DualStack@af-south-1
5908    #[test]
5909    fn test_213() {
5910        let params = crate::config::endpoint::Params::builder()
5911            .accelerate(false)
5912            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5913            .force_path_style(false)
5914            .region("af-south-1".to_string())
5915            .use_dual_stack(true)
5916            .use_fips(true)
5917            .build()
5918            .expect("invalid params");
5919        let resolver = crate::config::endpoint::DefaultResolver::new();
5920        let endpoint = resolver.resolve_endpoint(&params);
5921        let endpoint =
5922            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.af-south-1.amazonaws.com");
5923        assert_eq!(
5924            endpoint,
5925            ::aws_smithy_types::endpoint::Endpoint::builder()
5926                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.af-south-1.amazonaws.com")
5927                .property(
5928                    "authSchemes",
5929                    vec![::aws_smithy_types::Document::from({
5930                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5931                        out.insert("name".to_string(), "sigv4".to_string().into());
5932                        out.insert("signingName".to_string(), "s3".to_string().into());
5933                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5934                        out.insert("disableDoubleEncoding".to_string(), true.into());
5935                        out
5936                    })]
5937                )
5938                .build()
5939        );
5940    }
5941
5942    /// S3 outposts vanilla test
5943    #[test]
5944    fn test_214() {
5945        let params = crate::config::endpoint::Params::builder()
5946            .region("us-west-2".to_string())
5947            .use_fips(false)
5948            .use_dual_stack(false)
5949            .accelerate(false)
5950            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
5951            .build()
5952            .expect("invalid params");
5953        let resolver = crate::config::endpoint::DefaultResolver::new();
5954        let endpoint = resolver.resolve_endpoint(&params);
5955        let endpoint =
5956            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-west-2.amazonaws.com");
5957        assert_eq!(
5958            endpoint,
5959            ::aws_smithy_types::endpoint::Endpoint::builder()
5960                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-west-2.amazonaws.com")
5961                .property(
5962                    "authSchemes",
5963                    vec![
5964                        ::aws_smithy_types::Document::from({
5965                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5966                            out.insert("name".to_string(), "sigv4a".to_string().into());
5967                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
5968                            out.insert(
5969                                "signingRegionSet".to_string(),
5970                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
5971                            );
5972                            out.insert("disableDoubleEncoding".to_string(), true.into());
5973                            out
5974                        }),
5975                        ::aws_smithy_types::Document::from({
5976                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5977                            out.insert("name".to_string(), "sigv4".to_string().into());
5978                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
5979                            out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5980                            out.insert("disableDoubleEncoding".to_string(), true.into());
5981                            out
5982                        })
5983                    ]
5984                )
5985                .build()
5986        );
5987    }
5988
5989    /// S3 outposts custom endpoint
5990    #[test]
5991    fn test_215() {
5992        let params = crate::config::endpoint::Params::builder()
5993            .region("us-west-2".to_string())
5994            .use_fips(false)
5995            .use_dual_stack(false)
5996            .accelerate(false)
5997            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
5998            .endpoint("https://example.amazonaws.com".to_string())
5999            .build()
6000            .expect("invalid params");
6001        let resolver = crate::config::endpoint::DefaultResolver::new();
6002        let endpoint = resolver.resolve_endpoint(&params);
6003        let endpoint = endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.example.amazonaws.com");
6004        assert_eq!(
6005            endpoint,
6006            ::aws_smithy_types::endpoint::Endpoint::builder()
6007                .url("https://reports-123456789012.op-01234567890123456.example.amazonaws.com")
6008                .property(
6009                    "authSchemes",
6010                    vec![
6011                        ::aws_smithy_types::Document::from({
6012                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6013                            out.insert("name".to_string(), "sigv4a".to_string().into());
6014                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6015                            out.insert(
6016                                "signingRegionSet".to_string(),
6017                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
6018                            );
6019                            out.insert("disableDoubleEncoding".to_string(), true.into());
6020                            out
6021                        }),
6022                        ::aws_smithy_types::Document::from({
6023                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6024                            out.insert("name".to_string(), "sigv4".to_string().into());
6025                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6026                            out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6027                            out.insert("disableDoubleEncoding".to_string(), true.into());
6028                            out
6029                        })
6030                    ]
6031                )
6032                .build()
6033        );
6034    }
6035
6036    /// outposts arn with region mismatch and UseArnRegion=false
6037    #[test]
6038    fn test_216() {
6039        let params = crate::config::endpoint::Params::builder()
6040            .accelerate(false)
6041            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6042            .force_path_style(false)
6043            .use_arn_region(false)
6044            .region("us-west-2".to_string())
6045            .use_dual_stack(false)
6046            .use_fips(false)
6047            .build()
6048            .expect("invalid params");
6049        let resolver = crate::config::endpoint::DefaultResolver::new();
6050        let endpoint = resolver.resolve_endpoint(&params);
6051        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]");
6052        assert_eq!(
6053            format!("{}", error),
6054            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
6055        )
6056    }
6057
6058    /// outposts arn with region mismatch, custom region and UseArnRegion=false
6059    #[test]
6060    fn test_217() {
6061        let params = crate::config::endpoint::Params::builder()
6062            .accelerate(false)
6063            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6064            .endpoint("https://example.com".to_string())
6065            .force_path_style(false)
6066            .use_arn_region(false)
6067            .region("us-west-2".to_string())
6068            .use_dual_stack(false)
6069            .use_fips(false)
6070            .build()
6071            .expect("invalid params");
6072        let resolver = crate::config::endpoint::DefaultResolver::new();
6073        let endpoint = resolver.resolve_endpoint(&params);
6074        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]");
6075        assert_eq!(
6076            format!("{}", error),
6077            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
6078        )
6079    }
6080
6081    /// outposts arn with region mismatch and UseArnRegion=true
6082    #[test]
6083    fn test_218() {
6084        let params = crate::config::endpoint::Params::builder()
6085            .accelerate(false)
6086            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6087            .force_path_style(false)
6088            .use_arn_region(true)
6089            .region("us-west-2".to_string())
6090            .use_dual_stack(false)
6091            .use_fips(false)
6092            .build()
6093            .expect("invalid params");
6094        let resolver = crate::config::endpoint::DefaultResolver::new();
6095        let endpoint = resolver.resolve_endpoint(&params);
6096        let endpoint =
6097            endpoint.expect("Expected valid endpoint: https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
6098        assert_eq!(
6099            endpoint,
6100            ::aws_smithy_types::endpoint::Endpoint::builder()
6101                .url("https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
6102                .property(
6103                    "authSchemes",
6104                    vec![
6105                        ::aws_smithy_types::Document::from({
6106                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6107                            out.insert("name".to_string(), "sigv4a".to_string().into());
6108                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6109                            out.insert(
6110                                "signingRegionSet".to_string(),
6111                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
6112                            );
6113                            out.insert("disableDoubleEncoding".to_string(), true.into());
6114                            out
6115                        }),
6116                        ::aws_smithy_types::Document::from({
6117                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6118                            out.insert("name".to_string(), "sigv4".to_string().into());
6119                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6120                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6121                            out.insert("disableDoubleEncoding".to_string(), true.into());
6122                            out
6123                        })
6124                    ]
6125                )
6126                .build()
6127        );
6128    }
6129
6130    /// outposts arn with region mismatch and UseArnRegion unset
6131    #[test]
6132    fn test_219() {
6133        let params = crate::config::endpoint::Params::builder()
6134            .accelerate(false)
6135            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6136            .force_path_style(false)
6137            .region("us-west-2".to_string())
6138            .use_dual_stack(false)
6139            .use_fips(false)
6140            .build()
6141            .expect("invalid params");
6142        let resolver = crate::config::endpoint::DefaultResolver::new();
6143        let endpoint = resolver.resolve_endpoint(&params);
6144        let endpoint =
6145            endpoint.expect("Expected valid endpoint: https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
6146        assert_eq!(
6147            endpoint,
6148            ::aws_smithy_types::endpoint::Endpoint::builder()
6149                .url("https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
6150                .property(
6151                    "authSchemes",
6152                    vec![
6153                        ::aws_smithy_types::Document::from({
6154                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6155                            out.insert("name".to_string(), "sigv4a".to_string().into());
6156                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6157                            out.insert(
6158                                "signingRegionSet".to_string(),
6159                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
6160                            );
6161                            out.insert("disableDoubleEncoding".to_string(), true.into());
6162                            out
6163                        }),
6164                        ::aws_smithy_types::Document::from({
6165                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6166                            out.insert("name".to_string(), "sigv4".to_string().into());
6167                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6168                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6169                            out.insert("disableDoubleEncoding".to_string(), true.into());
6170                            out
6171                        })
6172                    ]
6173                )
6174                .build()
6175        );
6176    }
6177
6178    /// outposts arn with partition mismatch and UseArnRegion=true
6179    #[test]
6180    fn test_220() {
6181        let params = crate::config::endpoint::Params::builder()
6182            .accelerate(false)
6183            .bucket("arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6184            .force_path_style(false)
6185            .use_arn_region(true)
6186            .region("us-west-2".to_string())
6187            .use_dual_stack(false)
6188            .use_fips(false)
6189            .build()
6190            .expect("invalid params");
6191        let resolver = crate::config::endpoint::DefaultResolver::new();
6192        let endpoint = resolver.resolve_endpoint(&params);
6193        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]");
6194        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`")
6195    }
6196
6197    /// ARN with UseGlobalEndpoint and use-east-1 region uses the regional endpoint
6198    #[test]
6199    fn test_221() {
6200        let params = crate::config::endpoint::Params::builder()
6201            .region("us-east-1".to_string())
6202            .use_global_endpoint(true)
6203            .use_fips(false)
6204            .use_dual_stack(false)
6205            .accelerate(false)
6206            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6207            .build()
6208            .expect("invalid params");
6209        let resolver = crate::config::endpoint::DefaultResolver::new();
6210        let endpoint = resolver.resolve_endpoint(&params);
6211        let endpoint =
6212            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
6213        assert_eq!(
6214            endpoint,
6215            ::aws_smithy_types::endpoint::Endpoint::builder()
6216                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
6217                .property(
6218                    "authSchemes",
6219                    vec![
6220                        ::aws_smithy_types::Document::from({
6221                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6222                            out.insert("name".to_string(), "sigv4a".to_string().into());
6223                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6224                            out.insert(
6225                                "signingRegionSet".to_string(),
6226                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
6227                            );
6228                            out.insert("disableDoubleEncoding".to_string(), true.into());
6229                            out
6230                        }),
6231                        ::aws_smithy_types::Document::from({
6232                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6233                            out.insert("name".to_string(), "sigv4".to_string().into());
6234                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6235                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6236                            out.insert("disableDoubleEncoding".to_string(), true.into());
6237                            out
6238                        })
6239                    ]
6240                )
6241                .build()
6242        );
6243    }
6244
6245    /// S3 outposts does not support dualstack
6246    #[test]
6247    fn test_222() {
6248        let params = crate::config::endpoint::Params::builder()
6249            .region("us-east-1".to_string())
6250            .use_fips(false)
6251            .use_dual_stack(true)
6252            .accelerate(false)
6253            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6254            .build()
6255            .expect("invalid params");
6256        let resolver = crate::config::endpoint::DefaultResolver::new();
6257        let endpoint = resolver.resolve_endpoint(&params);
6258        let error = endpoint.expect_err("expected error: S3 Outposts does not support Dual-stack [S3 outposts does not support dualstack]");
6259        assert_eq!(format!("{}", error), "S3 Outposts does not support Dual-stack")
6260    }
6261
6262    /// S3 outposts does not support fips
6263    #[test]
6264    fn test_223() {
6265        let params = crate::config::endpoint::Params::builder()
6266            .region("us-east-1".to_string())
6267            .use_fips(true)
6268            .use_dual_stack(false)
6269            .accelerate(false)
6270            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6271            .build()
6272            .expect("invalid params");
6273        let resolver = crate::config::endpoint::DefaultResolver::new();
6274        let endpoint = resolver.resolve_endpoint(&params);
6275        let error = endpoint.expect_err("expected error: S3 Outposts does not support FIPS [S3 outposts does not support fips]");
6276        assert_eq!(format!("{}", error), "S3 Outposts does not support FIPS")
6277    }
6278
6279    /// S3 outposts does not support accelerate
6280    #[test]
6281    fn test_224() {
6282        let params = crate::config::endpoint::Params::builder()
6283            .region("us-east-1".to_string())
6284            .use_fips(false)
6285            .use_dual_stack(false)
6286            .accelerate(true)
6287            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6288            .build()
6289            .expect("invalid params");
6290        let resolver = crate::config::endpoint::DefaultResolver::new();
6291        let endpoint = resolver.resolve_endpoint(&params);
6292        let error = endpoint.expect_err("expected error: S3 Outposts does not support S3 Accelerate [S3 outposts does not support accelerate]");
6293        assert_eq!(format!("{}", error), "S3 Outposts does not support S3 Accelerate")
6294    }
6295
6296    /// validates against subresource
6297    #[test]
6298    fn test_225() {
6299        let params = crate::config::endpoint::Params::builder()
6300            .region("us-west-2".to_string())
6301            .use_fips(false)
6302            .use_dual_stack(false)
6303            .accelerate(false)
6304            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:mybucket:object:foo".to_string())
6305            .build()
6306            .expect("invalid params");
6307        let resolver = crate::config::endpoint::DefaultResolver::new();
6308        let endpoint = resolver.resolve_endpoint(&params);
6309        let error =
6310            endpoint.expect_err("expected error: Invalid Arn: Outpost Access Point ARN contains sub resources [validates against subresource]");
6311        assert_eq!(format!("{}", error), "Invalid Arn: Outpost Access Point ARN contains sub resources")
6312    }
6313
6314    /// object lambda @us-east-1
6315    #[test]
6316    fn test_226() {
6317        let params = crate::config::endpoint::Params::builder()
6318            .region("us-east-1".to_string())
6319            .use_fips(false)
6320            .use_dual_stack(false)
6321            .accelerate(false)
6322            .use_arn_region(false)
6323            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6324            .build()
6325            .expect("invalid params");
6326        let resolver = crate::config::endpoint::DefaultResolver::new();
6327        let endpoint = resolver.resolve_endpoint(&params);
6328        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
6329        assert_eq!(
6330            endpoint,
6331            ::aws_smithy_types::endpoint::Endpoint::builder()
6332                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
6333                .property(
6334                    "authSchemes",
6335                    vec![::aws_smithy_types::Document::from({
6336                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6337                        out.insert("name".to_string(), "sigv4".to_string().into());
6338                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6339                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6340                        out.insert("disableDoubleEncoding".to_string(), true.into());
6341                        out
6342                    })]
6343                )
6344                .build()
6345        );
6346    }
6347
6348    /// object lambda @us-west-2
6349    #[test]
6350    fn test_227() {
6351        let params = crate::config::endpoint::Params::builder()
6352            .region("us-west-2".to_string())
6353            .use_fips(false)
6354            .use_dual_stack(false)
6355            .accelerate(false)
6356            .use_arn_region(false)
6357            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
6358            .build()
6359            .expect("invalid params");
6360        let resolver = crate::config::endpoint::DefaultResolver::new();
6361        let endpoint = resolver.resolve_endpoint(&params);
6362        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com");
6363        assert_eq!(
6364            endpoint,
6365            ::aws_smithy_types::endpoint::Endpoint::builder()
6366                .url("https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com")
6367                .property(
6368                    "authSchemes",
6369                    vec![::aws_smithy_types::Document::from({
6370                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6371                        out.insert("name".to_string(), "sigv4".to_string().into());
6372                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6373                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6374                        out.insert("disableDoubleEncoding".to_string(), true.into());
6375                        out
6376                    })]
6377                )
6378                .build()
6379        );
6380    }
6381
6382    /// object lambda, colon resource deliminator @us-west-2
6383    #[test]
6384    fn test_228() {
6385        let params = crate::config::endpoint::Params::builder()
6386            .region("us-west-2".to_string())
6387            .use_fips(false)
6388            .use_dual_stack(false)
6389            .accelerate(false)
6390            .use_arn_region(false)
6391            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:mybanner".to_string())
6392            .build()
6393            .expect("invalid params");
6394        let resolver = crate::config::endpoint::DefaultResolver::new();
6395        let endpoint = resolver.resolve_endpoint(&params);
6396        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com");
6397        assert_eq!(
6398            endpoint,
6399            ::aws_smithy_types::endpoint::Endpoint::builder()
6400                .url("https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com")
6401                .property(
6402                    "authSchemes",
6403                    vec![::aws_smithy_types::Document::from({
6404                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6405                        out.insert("name".to_string(), "sigv4".to_string().into());
6406                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6407                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6408                        out.insert("disableDoubleEncoding".to_string(), true.into());
6409                        out
6410                    })]
6411                )
6412                .build()
6413        );
6414    }
6415
6416    /// object lambda @us-east-1, client region us-west-2, useArnRegion=true
6417    #[test]
6418    fn test_229() {
6419        let params = crate::config::endpoint::Params::builder()
6420            .region("us-west-2".to_string())
6421            .use_fips(false)
6422            .use_dual_stack(false)
6423            .accelerate(false)
6424            .use_arn_region(true)
6425            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6426            .build()
6427            .expect("invalid params");
6428        let resolver = crate::config::endpoint::DefaultResolver::new();
6429        let endpoint = resolver.resolve_endpoint(&params);
6430        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
6431        assert_eq!(
6432            endpoint,
6433            ::aws_smithy_types::endpoint::Endpoint::builder()
6434                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
6435                .property(
6436                    "authSchemes",
6437                    vec![::aws_smithy_types::Document::from({
6438                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6439                        out.insert("name".to_string(), "sigv4".to_string().into());
6440                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6441                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6442                        out.insert("disableDoubleEncoding".to_string(), true.into());
6443                        out
6444                    })]
6445                )
6446                .build()
6447        );
6448    }
6449
6450    /// object lambda @us-east-1, client region s3-external-1, useArnRegion=true
6451    #[test]
6452    fn test_230() {
6453        let params = crate::config::endpoint::Params::builder()
6454            .region("s3-external-1".to_string())
6455            .use_fips(false)
6456            .use_dual_stack(false)
6457            .accelerate(false)
6458            .use_arn_region(true)
6459            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6460            .build()
6461            .expect("invalid params");
6462        let resolver = crate::config::endpoint::DefaultResolver::new();
6463        let endpoint = resolver.resolve_endpoint(&params);
6464        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
6465        assert_eq!(
6466            endpoint,
6467            ::aws_smithy_types::endpoint::Endpoint::builder()
6468                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
6469                .property(
6470                    "authSchemes",
6471                    vec![::aws_smithy_types::Document::from({
6472                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6473                        out.insert("name".to_string(), "sigv4".to_string().into());
6474                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6475                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6476                        out.insert("disableDoubleEncoding".to_string(), true.into());
6477                        out
6478                    })]
6479                )
6480                .build()
6481        );
6482    }
6483
6484    /// object lambda @us-east-1, client region s3-external-1, useArnRegion=false
6485    #[test]
6486    fn test_231() {
6487        let params = crate::config::endpoint::Params::builder()
6488            .region("s3-external-1".to_string())
6489            .use_fips(false)
6490            .use_dual_stack(false)
6491            .accelerate(false)
6492            .use_arn_region(false)
6493            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6494            .build()
6495            .expect("invalid params");
6496        let resolver = crate::config::endpoint::DefaultResolver::new();
6497        let endpoint = resolver.resolve_endpoint(&params);
6498        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]");
6499        assert_eq!(
6500            format!("{}", error),
6501            "Invalid configuration: region from ARN `us-east-1` does not match client region `s3-external-1` and UseArnRegion is `false`"
6502        )
6503    }
6504
6505    /// object lambda @us-east-1, client region aws-global, useArnRegion=true
6506    #[test]
6507    fn test_232() {
6508        let params = crate::config::endpoint::Params::builder()
6509            .region("aws-global".to_string())
6510            .use_fips(false)
6511            .use_dual_stack(false)
6512            .accelerate(false)
6513            .use_arn_region(true)
6514            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6515            .build()
6516            .expect("invalid params");
6517        let resolver = crate::config::endpoint::DefaultResolver::new();
6518        let endpoint = resolver.resolve_endpoint(&params);
6519        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
6520        assert_eq!(
6521            endpoint,
6522            ::aws_smithy_types::endpoint::Endpoint::builder()
6523                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
6524                .property(
6525                    "authSchemes",
6526                    vec![::aws_smithy_types::Document::from({
6527                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6528                        out.insert("name".to_string(), "sigv4".to_string().into());
6529                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6530                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6531                        out.insert("disableDoubleEncoding".to_string(), true.into());
6532                        out
6533                    })]
6534                )
6535                .build()
6536        );
6537    }
6538
6539    /// object lambda @us-east-1, client region aws-global, useArnRegion=false
6540    #[test]
6541    fn test_233() {
6542        let params = crate::config::endpoint::Params::builder()
6543            .region("aws-global".to_string())
6544            .use_fips(false)
6545            .use_dual_stack(false)
6546            .accelerate(false)
6547            .use_arn_region(false)
6548            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6549            .build()
6550            .expect("invalid params");
6551        let resolver = crate::config::endpoint::DefaultResolver::new();
6552        let endpoint = resolver.resolve_endpoint(&params);
6553        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]");
6554        assert_eq!(
6555            format!("{}", error),
6556            "Invalid configuration: region from ARN `us-east-1` does not match client region `aws-global` and UseArnRegion is `false`"
6557        )
6558    }
6559
6560    /// object lambda @cn-north-1, client region us-west-2 (cross partition), useArnRegion=true
6561    #[test]
6562    fn test_234() {
6563        let params = crate::config::endpoint::Params::builder()
6564            .region("aws-global".to_string())
6565            .use_fips(false)
6566            .use_dual_stack(false)
6567            .accelerate(false)
6568            .use_arn_region(true)
6569            .bucket("arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner".to_string())
6570            .build()
6571            .expect("invalid params");
6572        let resolver = crate::config::endpoint::DefaultResolver::new();
6573        let endpoint = resolver.resolve_endpoint(&params);
6574        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]");
6575        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`")
6576    }
6577
6578    /// object lambda with dualstack
6579    #[test]
6580    fn test_235() {
6581        let params = crate::config::endpoint::Params::builder()
6582            .region("us-west-2".to_string())
6583            .use_fips(false)
6584            .use_dual_stack(true)
6585            .accelerate(false)
6586            .use_arn_region(false)
6587            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
6588            .build()
6589            .expect("invalid params");
6590        let resolver = crate::config::endpoint::DefaultResolver::new();
6591        let endpoint = resolver.resolve_endpoint(&params);
6592        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support Dual-stack [object lambda with dualstack]");
6593        assert_eq!(format!("{}", error), "S3 Object Lambda does not support Dual-stack")
6594    }
6595
6596    /// object lambda @us-gov-east-1
6597    #[test]
6598    fn test_236() {
6599        let params = crate::config::endpoint::Params::builder()
6600            .region("us-gov-east-1".to_string())
6601            .use_fips(false)
6602            .use_dual_stack(false)
6603            .accelerate(false)
6604            .use_arn_region(false)
6605            .bucket("arn:aws-us-gov:s3-object-lambda:us-gov-east-1:123456789012:accesspoint/mybanner".to_string())
6606            .build()
6607            .expect("invalid params");
6608        let resolver = crate::config::endpoint::DefaultResolver::new();
6609        let endpoint = resolver.resolve_endpoint(&params);
6610        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-gov-east-1.amazonaws.com");
6611        assert_eq!(
6612            endpoint,
6613            ::aws_smithy_types::endpoint::Endpoint::builder()
6614                .url("https://mybanner-123456789012.s3-object-lambda.us-gov-east-1.amazonaws.com")
6615                .property(
6616                    "authSchemes",
6617                    vec![::aws_smithy_types::Document::from({
6618                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6619                        out.insert("name".to_string(), "sigv4".to_string().into());
6620                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6621                        out.insert("signingRegion".to_string(), "us-gov-east-1".to_string().into());
6622                        out.insert("disableDoubleEncoding".to_string(), true.into());
6623                        out
6624                    })]
6625                )
6626                .build()
6627        );
6628    }
6629
6630    /// object lambda @us-gov-east-1, with fips
6631    #[test]
6632    fn test_237() {
6633        let params = crate::config::endpoint::Params::builder()
6634            .region("us-gov-east-1".to_string())
6635            .use_fips(true)
6636            .use_dual_stack(false)
6637            .accelerate(false)
6638            .use_arn_region(false)
6639            .bucket("arn:aws-us-gov:s3-object-lambda:us-gov-east-1:123456789012:accesspoint/mybanner".to_string())
6640            .build()
6641            .expect("invalid params");
6642        let resolver = crate::config::endpoint::DefaultResolver::new();
6643        let endpoint = resolver.resolve_endpoint(&params);
6644        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda-fips.us-gov-east-1.amazonaws.com");
6645        assert_eq!(
6646            endpoint,
6647            ::aws_smithy_types::endpoint::Endpoint::builder()
6648                .url("https://mybanner-123456789012.s3-object-lambda-fips.us-gov-east-1.amazonaws.com")
6649                .property(
6650                    "authSchemes",
6651                    vec![::aws_smithy_types::Document::from({
6652                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6653                        out.insert("name".to_string(), "sigv4".to_string().into());
6654                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6655                        out.insert("signingRegion".to_string(), "us-gov-east-1".to_string().into());
6656                        out.insert("disableDoubleEncoding".to_string(), true.into());
6657                        out
6658                    })]
6659                )
6660                .build()
6661        );
6662    }
6663
6664    /// object lambda @cn-north-1, with fips
6665    #[test]
6666    fn test_238() {
6667        let params = crate::config::endpoint::Params::builder()
6668            .region("cn-north-1".to_string())
6669            .use_fips(true)
6670            .use_dual_stack(false)
6671            .accelerate(false)
6672            .use_arn_region(false)
6673            .bucket("arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner".to_string())
6674            .build()
6675            .expect("invalid params");
6676        let resolver = crate::config::endpoint::DefaultResolver::new();
6677        let endpoint = resolver.resolve_endpoint(&params);
6678        let error = endpoint.expect_err("expected error: Partition does not support FIPS [object lambda @cn-north-1, with fips]");
6679        assert_eq!(format!("{}", error), "Partition does not support FIPS")
6680    }
6681
6682    /// object lambda with accelerate
6683    #[test]
6684    fn test_239() {
6685        let params = crate::config::endpoint::Params::builder()
6686            .region("us-west-2".to_string())
6687            .use_fips(false)
6688            .use_dual_stack(false)
6689            .accelerate(true)
6690            .use_arn_region(false)
6691            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
6692            .build()
6693            .expect("invalid params");
6694        let resolver = crate::config::endpoint::DefaultResolver::new();
6695        let endpoint = resolver.resolve_endpoint(&params);
6696        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support S3 Accelerate [object lambda with accelerate]");
6697        assert_eq!(format!("{}", error), "S3 Object Lambda does not support S3 Accelerate")
6698    }
6699
6700    /// object lambda with invalid arn - bad service and someresource
6701    #[test]
6702    fn test_240() {
6703        let params = crate::config::endpoint::Params::builder()
6704            .region("us-west-2".to_string())
6705            .use_fips(false)
6706            .use_dual_stack(false)
6707            .accelerate(false)
6708            .use_arn_region(false)
6709            .bucket("arn:aws:sqs:us-west-2:123456789012:someresource".to_string())
6710            .build()
6711            .expect("invalid params");
6712        let resolver = crate::config::endpoint::DefaultResolver::new();
6713        let endpoint = resolver.resolve_endpoint(&params);
6714        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]");
6715        assert_eq!(
6716            format!("{}", error),
6717            "Invalid ARN: Unrecognized format: arn:aws:sqs:us-west-2:123456789012:someresource (type: someresource)"
6718        )
6719    }
6720
6721    /// object lambda with invalid arn - invalid resource
6722    #[test]
6723    fn test_241() {
6724        let params = crate::config::endpoint::Params::builder()
6725            .region("us-west-2".to_string())
6726            .use_fips(false)
6727            .use_dual_stack(false)
6728            .accelerate(false)
6729            .use_arn_region(false)
6730            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:bucket_name:mybucket".to_string())
6731            .build()
6732            .expect("invalid params");
6733        let resolver = crate::config::endpoint::DefaultResolver::new();
6734        let endpoint = resolver.resolve_endpoint(&params);
6735        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]");
6736        assert_eq!(
6737            format!("{}", error),
6738            "Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `bucket_name`"
6739        )
6740    }
6741
6742    /// object lambda with invalid arn - missing region
6743    #[test]
6744    fn test_242() {
6745        let params = crate::config::endpoint::Params::builder()
6746            .region("us-west-2".to_string())
6747            .use_fips(false)
6748            .use_dual_stack(false)
6749            .accelerate(false)
6750            .use_arn_region(false)
6751            .bucket("arn:aws:s3-object-lambda::123456789012:accesspoint/mybanner".to_string())
6752            .build()
6753            .expect("invalid params");
6754        let resolver = crate::config::endpoint::DefaultResolver::new();
6755        let endpoint = resolver.resolve_endpoint(&params);
6756        let error =
6757            endpoint.expect_err("expected error: Invalid ARN: bucket ARN is missing a region [object lambda with invalid arn - missing region]");
6758        assert_eq!(format!("{}", error), "Invalid ARN: bucket ARN is missing a region")
6759    }
6760
6761    /// object lambda with invalid arn - missing account-id
6762    #[test]
6763    fn test_243() {
6764        let params = crate::config::endpoint::Params::builder()
6765            .region("us-west-2".to_string())
6766            .use_fips(false)
6767            .use_dual_stack(false)
6768            .accelerate(false)
6769            .use_arn_region(true)
6770            .bucket("arn:aws:s3-object-lambda:us-west-2::accesspoint/mybanner".to_string())
6771            .build()
6772            .expect("invalid params");
6773        let resolver = crate::config::endpoint::DefaultResolver::new();
6774        let endpoint = resolver.resolve_endpoint(&params);
6775        let error = endpoint.expect_err("expected error: Invalid ARN: Missing account id [object lambda with invalid arn - missing account-id]");
6776        assert_eq!(format!("{}", error), "Invalid ARN: Missing account id")
6777    }
6778
6779    /// object lambda with invalid arn - account id contains invalid characters
6780    #[test]
6781    fn test_244() {
6782        let params = crate::config::endpoint::Params::builder()
6783            .region("us-west-2".to_string())
6784            .use_fips(false)
6785            .use_dual_stack(false)
6786            .accelerate(false)
6787            .use_arn_region(true)
6788            .bucket("arn:aws:s3-object-lambda:us-west-2:123.45678.9012:accesspoint:mybucket".to_string())
6789            .build()
6790            .expect("invalid params");
6791        let resolver = crate::config::endpoint::DefaultResolver::new();
6792        let endpoint = resolver.resolve_endpoint(&params);
6793        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]");
6794        assert_eq!(
6795            format!("{}", error),
6796            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123.45678.9012`"
6797        )
6798    }
6799
6800    /// object lambda with invalid arn - missing access point name
6801    #[test]
6802    fn test_245() {
6803        let params = crate::config::endpoint::Params::builder()
6804            .region("us-west-2".to_string())
6805            .use_fips(false)
6806            .use_dual_stack(false)
6807            .accelerate(false)
6808            .use_arn_region(true)
6809            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint".to_string())
6810            .build()
6811            .expect("invalid params");
6812        let resolver = crate::config::endpoint::DefaultResolver::new();
6813        let endpoint = resolver.resolve_endpoint(&params);
6814        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]");
6815        assert_eq!(
6816            format!("{}", error),
6817            "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided"
6818        )
6819    }
6820
6821    /// object lambda with invalid arn - access point name contains invalid character: *
6822    #[test]
6823    fn test_246() {
6824        let params = crate::config::endpoint::Params::builder()
6825            .region("us-west-2".to_string())
6826            .use_fips(false)
6827            .use_dual_stack(false)
6828            .accelerate(false)
6829            .use_arn_region(true)
6830            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:*".to_string())
6831            .build()
6832            .expect("invalid params");
6833        let resolver = crate::config::endpoint::DefaultResolver::new();
6834        let endpoint = resolver.resolve_endpoint(&params);
6835        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: *]");
6836        assert_eq!(
6837            format!("{}", error),
6838            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `*`"
6839        )
6840    }
6841
6842    /// object lambda with invalid arn - access point name contains invalid character: .
6843    #[test]
6844    fn test_247() {
6845        let params = crate::config::endpoint::Params::builder()
6846            .region("us-west-2".to_string())
6847            .use_fips(false)
6848            .use_dual_stack(false)
6849            .accelerate(false)
6850            .use_arn_region(true)
6851            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:my.bucket".to_string())
6852            .build()
6853            .expect("invalid params");
6854        let resolver = crate::config::endpoint::DefaultResolver::new();
6855        let endpoint = resolver.resolve_endpoint(&params);
6856        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: .]");
6857        assert_eq!(
6858            format!("{}", error),
6859            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `my.bucket`"
6860        )
6861    }
6862
6863    /// object lambda with invalid arn - access point name contains sub resources
6864    #[test]
6865    fn test_248() {
6866        let params = crate::config::endpoint::Params::builder()
6867            .region("us-west-2".to_string())
6868            .use_fips(false)
6869            .use_dual_stack(false)
6870            .accelerate(false)
6871            .use_arn_region(true)
6872            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:mybucket:object:foo".to_string())
6873            .build()
6874            .expect("invalid params");
6875        let resolver = crate::config::endpoint::DefaultResolver::new();
6876        let endpoint = resolver.resolve_endpoint(&params);
6877        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]");
6878        assert_eq!(
6879            format!("{}", error),
6880            "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`."
6881        )
6882    }
6883
6884    /// object lambda with custom endpoint
6885    #[test]
6886    fn test_249() {
6887        let params = crate::config::endpoint::Params::builder()
6888            .region("us-west-2".to_string())
6889            .use_fips(false)
6890            .use_dual_stack(false)
6891            .accelerate(false)
6892            .use_arn_region(false)
6893            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
6894            .endpoint("https://my-endpoint.com".to_string())
6895            .build()
6896            .expect("invalid params");
6897        let resolver = crate::config::endpoint::DefaultResolver::new();
6898        let endpoint = resolver.resolve_endpoint(&params);
6899        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.my-endpoint.com");
6900        assert_eq!(
6901            endpoint,
6902            ::aws_smithy_types::endpoint::Endpoint::builder()
6903                .url("https://mybanner-123456789012.my-endpoint.com")
6904                .property(
6905                    "authSchemes",
6906                    vec![::aws_smithy_types::Document::from({
6907                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6908                        out.insert("name".to_string(), "sigv4".to_string().into());
6909                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6910                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6911                        out.insert("disableDoubleEncoding".to_string(), true.into());
6912                        out
6913                    })]
6914                )
6915                .build()
6916        );
6917    }
6918
6919    /// object lambda arn with region mismatch and UseArnRegion=false
6920    #[test]
6921    fn test_250() {
6922        let params = crate::config::endpoint::Params::builder()
6923            .accelerate(false)
6924            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6925            .force_path_style(false)
6926            .use_arn_region(false)
6927            .region("us-west-2".to_string())
6928            .use_dual_stack(false)
6929            .use_fips(false)
6930            .build()
6931            .expect("invalid params");
6932        let resolver = crate::config::endpoint::DefaultResolver::new();
6933        let endpoint = resolver.resolve_endpoint(&params);
6934        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]");
6935        assert_eq!(
6936            format!("{}", error),
6937            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
6938        )
6939    }
6940
6941    /// WriteGetObjectResponse @ us-west-2
6942    #[test]
6943    fn test_251() {
6944        let params = crate::config::endpoint::Params::builder()
6945            .accelerate(false)
6946            .use_object_lambda_endpoint(true)
6947            .region("us-west-2".to_string())
6948            .use_dual_stack(false)
6949            .use_fips(false)
6950            .build()
6951            .expect("invalid params");
6952        let resolver = crate::config::endpoint::DefaultResolver::new();
6953        let endpoint = resolver.resolve_endpoint(&params);
6954        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-west-2.amazonaws.com");
6955        assert_eq!(
6956            endpoint,
6957            ::aws_smithy_types::endpoint::Endpoint::builder()
6958                .url("https://s3-object-lambda.us-west-2.amazonaws.com")
6959                .property(
6960                    "authSchemes",
6961                    vec![::aws_smithy_types::Document::from({
6962                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6963                        out.insert("name".to_string(), "sigv4".to_string().into());
6964                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6965                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6966                        out.insert("disableDoubleEncoding".to_string(), true.into());
6967                        out
6968                    })]
6969                )
6970                .build()
6971        );
6972    }
6973
6974    /// WriteGetObjectResponse with custom endpoint
6975    #[test]
6976    fn test_252() {
6977        let params = crate::config::endpoint::Params::builder()
6978            .accelerate(false)
6979            .use_object_lambda_endpoint(true)
6980            .endpoint("https://my-endpoint.com".to_string())
6981            .region("us-west-2".to_string())
6982            .use_dual_stack(false)
6983            .use_fips(false)
6984            .build()
6985            .expect("invalid params");
6986        let resolver = crate::config::endpoint::DefaultResolver::new();
6987        let endpoint = resolver.resolve_endpoint(&params);
6988        let endpoint = endpoint.expect("Expected valid endpoint: https://my-endpoint.com");
6989        assert_eq!(
6990            endpoint,
6991            ::aws_smithy_types::endpoint::Endpoint::builder()
6992                .url("https://my-endpoint.com")
6993                .property(
6994                    "authSchemes",
6995                    vec![::aws_smithy_types::Document::from({
6996                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6997                        out.insert("name".to_string(), "sigv4".to_string().into());
6998                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6999                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7000                        out.insert("disableDoubleEncoding".to_string(), true.into());
7001                        out
7002                    })]
7003                )
7004                .build()
7005        );
7006    }
7007
7008    /// WriteGetObjectResponse @ us-east-1
7009    #[test]
7010    fn test_253() {
7011        let params = crate::config::endpoint::Params::builder()
7012            .accelerate(false)
7013            .use_object_lambda_endpoint(true)
7014            .region("us-east-1".to_string())
7015            .use_dual_stack(false)
7016            .use_fips(false)
7017            .build()
7018            .expect("invalid params");
7019        let resolver = crate::config::endpoint::DefaultResolver::new();
7020        let endpoint = resolver.resolve_endpoint(&params);
7021        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-east-1.amazonaws.com");
7022        assert_eq!(
7023            endpoint,
7024            ::aws_smithy_types::endpoint::Endpoint::builder()
7025                .url("https://s3-object-lambda.us-east-1.amazonaws.com")
7026                .property(
7027                    "authSchemes",
7028                    vec![::aws_smithy_types::Document::from({
7029                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7030                        out.insert("name".to_string(), "sigv4".to_string().into());
7031                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7032                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7033                        out.insert("disableDoubleEncoding".to_string(), true.into());
7034                        out
7035                    })]
7036                )
7037                .build()
7038        );
7039    }
7040
7041    /// WriteGetObjectResponse with fips
7042    #[test]
7043    fn test_254() {
7044        let params = crate::config::endpoint::Params::builder()
7045            .accelerate(false)
7046            .use_object_lambda_endpoint(true)
7047            .region("us-east-1".to_string())
7048            .use_dual_stack(false)
7049            .use_fips(true)
7050            .build()
7051            .expect("invalid params");
7052        let resolver = crate::config::endpoint::DefaultResolver::new();
7053        let endpoint = resolver.resolve_endpoint(&params);
7054        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda-fips.us-east-1.amazonaws.com");
7055        assert_eq!(
7056            endpoint,
7057            ::aws_smithy_types::endpoint::Endpoint::builder()
7058                .url("https://s3-object-lambda-fips.us-east-1.amazonaws.com")
7059                .property(
7060                    "authSchemes",
7061                    vec![::aws_smithy_types::Document::from({
7062                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7063                        out.insert("name".to_string(), "sigv4".to_string().into());
7064                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7065                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7066                        out.insert("disableDoubleEncoding".to_string(), true.into());
7067                        out
7068                    })]
7069                )
7070                .build()
7071        );
7072    }
7073
7074    /// WriteGetObjectResponse with dualstack
7075    #[test]
7076    fn test_255() {
7077        let params = crate::config::endpoint::Params::builder()
7078            .accelerate(false)
7079            .use_object_lambda_endpoint(true)
7080            .region("us-east-1".to_string())
7081            .use_dual_stack(true)
7082            .use_fips(false)
7083            .build()
7084            .expect("invalid params");
7085        let resolver = crate::config::endpoint::DefaultResolver::new();
7086        let endpoint = resolver.resolve_endpoint(&params);
7087        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support Dual-stack [WriteGetObjectResponse with dualstack]");
7088        assert_eq!(format!("{}", error), "S3 Object Lambda does not support Dual-stack")
7089    }
7090
7091    /// WriteGetObjectResponse with accelerate
7092    #[test]
7093    fn test_256() {
7094        let params = crate::config::endpoint::Params::builder()
7095            .accelerate(true)
7096            .use_object_lambda_endpoint(true)
7097            .region("us-east-1".to_string())
7098            .use_dual_stack(false)
7099            .use_fips(false)
7100            .build()
7101            .expect("invalid params");
7102        let resolver = crate::config::endpoint::DefaultResolver::new();
7103        let endpoint = resolver.resolve_endpoint(&params);
7104        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support S3 Accelerate [WriteGetObjectResponse with accelerate]");
7105        assert_eq!(format!("{}", error), "S3 Object Lambda does not support S3 Accelerate")
7106    }
7107
7108    /// WriteGetObjectResponse with fips in CN
7109    #[test]
7110    fn test_257() {
7111        let params = crate::config::endpoint::Params::builder()
7112            .accelerate(false)
7113            .region("cn-north-1".to_string())
7114            .use_object_lambda_endpoint(true)
7115            .use_dual_stack(false)
7116            .use_fips(true)
7117            .build()
7118            .expect("invalid params");
7119        let resolver = crate::config::endpoint::DefaultResolver::new();
7120        let endpoint = resolver.resolve_endpoint(&params);
7121        let error = endpoint.expect_err("expected error: Partition does not support FIPS [WriteGetObjectResponse with fips in CN]");
7122        assert_eq!(format!("{}", error), "Partition does not support FIPS")
7123    }
7124
7125    /// WriteGetObjectResponse with invalid partition
7126    #[test]
7127    fn test_258() {
7128        let params = crate::config::endpoint::Params::builder()
7129            .accelerate(false)
7130            .use_object_lambda_endpoint(true)
7131            .region("not a valid DNS name".to_string())
7132            .use_dual_stack(false)
7133            .use_fips(false)
7134            .build()
7135            .expect("invalid params");
7136        let resolver = crate::config::endpoint::DefaultResolver::new();
7137        let endpoint = resolver.resolve_endpoint(&params);
7138        let error =
7139            endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [WriteGetObjectResponse with invalid partition]");
7140        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
7141    }
7142
7143    /// WriteGetObjectResponse with an unknown partition
7144    #[test]
7145    fn test_259() {
7146        let params = crate::config::endpoint::Params::builder()
7147            .accelerate(false)
7148            .use_object_lambda_endpoint(true)
7149            .region("us-east.special".to_string())
7150            .use_dual_stack(false)
7151            .use_fips(false)
7152            .build()
7153            .expect("invalid params");
7154        let resolver = crate::config::endpoint::DefaultResolver::new();
7155        let endpoint = resolver.resolve_endpoint(&params);
7156        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-east.special.amazonaws.com");
7157        assert_eq!(
7158            endpoint,
7159            ::aws_smithy_types::endpoint::Endpoint::builder()
7160                .url("https://s3-object-lambda.us-east.special.amazonaws.com")
7161                .property(
7162                    "authSchemes",
7163                    vec![::aws_smithy_types::Document::from({
7164                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7165                        out.insert("name".to_string(), "sigv4".to_string().into());
7166                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7167                        out.insert("disableDoubleEncoding".to_string(), true.into());
7168                        out.insert("signingRegion".to_string(), "us-east.special".to_string().into());
7169                        out
7170                    })]
7171                )
7172                .build()
7173        );
7174    }
7175
7176    /// S3 Outposts bucketAlias Real Outpost Prod us-west-1
7177    #[test]
7178    fn test_260() {
7179        let params = crate::config::endpoint::Params::builder()
7180            .region("us-west-1".to_string())
7181            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7182            .use_fips(false)
7183            .use_dual_stack(false)
7184            .accelerate(false)
7185            .build()
7186            .expect("invalid params");
7187        let resolver = crate::config::endpoint::DefaultResolver::new();
7188        let endpoint = resolver.resolve_endpoint(&params);
7189        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.us-west-1.amazonaws.com");
7190        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")
7191    .property("authSchemes", vec![::aws_smithy_types::Document::from( {
7192        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7193        out.insert("name".to_string(), "sigv4a".to_string().into());
7194        out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7195        out.insert("signingRegionSet".to_string(), vec![::aws_smithy_types::Document::from("*".to_string())].into());
7196        out.insert("disableDoubleEncoding".to_string(), true.into());
7197        out
7198    })
7199    ,::aws_smithy_types::Document::from( {
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-outposts".to_string().into());
7203        out.insert("signingRegion".to_string(), "us-west-1".to_string().into());
7204        out.insert("disableDoubleEncoding".to_string(), true.into());
7205        out
7206    })])
7207    .build());
7208    }
7209
7210    /// S3 Outposts bucketAlias Real Outpost Prod ap-east-1
7211    #[test]
7212    fn test_261() {
7213        let params = crate::config::endpoint::Params::builder()
7214            .region("ap-east-1".to_string())
7215            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7216            .use_fips(false)
7217            .use_dual_stack(false)
7218            .accelerate(false)
7219            .build()
7220            .expect("invalid params");
7221        let resolver = crate::config::endpoint::DefaultResolver::new();
7222        let endpoint = resolver.resolve_endpoint(&params);
7223        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.ap-east-1.amazonaws.com");
7224        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")
7225    .property("authSchemes", vec![::aws_smithy_types::Document::from( {
7226        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7227        out.insert("name".to_string(), "sigv4a".to_string().into());
7228        out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7229        out.insert("signingRegionSet".to_string(), vec![::aws_smithy_types::Document::from("*".to_string())].into());
7230        out.insert("disableDoubleEncoding".to_string(), true.into());
7231        out
7232    })
7233    ,::aws_smithy_types::Document::from( {
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-outposts".to_string().into());
7237        out.insert("signingRegion".to_string(), "ap-east-1".to_string().into());
7238        out.insert("disableDoubleEncoding".to_string(), true.into());
7239        out
7240    })])
7241    .build());
7242    }
7243
7244    /// S3 Outposts bucketAlias Ec2 Outpost Prod us-east-1
7245    #[test]
7246    fn test_262() {
7247        let params = crate::config::endpoint::Params::builder()
7248            .region("us-east-1".to_string())
7249            .bucket("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7250            .use_fips(false)
7251            .use_dual_stack(false)
7252            .accelerate(false)
7253            .build()
7254            .expect("invalid params");
7255        let resolver = crate::config::endpoint::DefaultResolver::new();
7256        let endpoint = resolver.resolve_endpoint(&params);
7257        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.us-east-1.amazonaws.com");
7258        assert_eq!(
7259            endpoint,
7260            ::aws_smithy_types::endpoint::Endpoint::builder()
7261                .url("https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.us-east-1.amazonaws.com")
7262                .property(
7263                    "authSchemes",
7264                    vec![
7265                        ::aws_smithy_types::Document::from({
7266                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7267                            out.insert("name".to_string(), "sigv4a".to_string().into());
7268                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7269                            out.insert(
7270                                "signingRegionSet".to_string(),
7271                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
7272                            );
7273                            out.insert("disableDoubleEncoding".to_string(), true.into());
7274                            out
7275                        }),
7276                        ::aws_smithy_types::Document::from({
7277                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7278                            out.insert("name".to_string(), "sigv4".to_string().into());
7279                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7280                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7281                            out.insert("disableDoubleEncoding".to_string(), true.into());
7282                            out
7283                        })
7284                    ]
7285                )
7286                .build()
7287        );
7288    }
7289
7290    /// S3 Outposts bucketAlias Ec2 Outpost Prod me-south-1
7291    #[test]
7292    fn test_263() {
7293        let params = crate::config::endpoint::Params::builder()
7294            .region("me-south-1".to_string())
7295            .bucket("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7296            .use_fips(false)
7297            .use_dual_stack(false)
7298            .accelerate(false)
7299            .build()
7300            .expect("invalid params");
7301        let resolver = crate::config::endpoint::DefaultResolver::new();
7302        let endpoint = resolver.resolve_endpoint(&params);
7303        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.me-south-1.amazonaws.com");
7304        assert_eq!(
7305            endpoint,
7306            ::aws_smithy_types::endpoint::Endpoint::builder()
7307                .url("https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.me-south-1.amazonaws.com")
7308                .property(
7309                    "authSchemes",
7310                    vec![
7311                        ::aws_smithy_types::Document::from({
7312                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7313                            out.insert("name".to_string(), "sigv4a".to_string().into());
7314                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7315                            out.insert(
7316                                "signingRegionSet".to_string(),
7317                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
7318                            );
7319                            out.insert("disableDoubleEncoding".to_string(), true.into());
7320                            out
7321                        }),
7322                        ::aws_smithy_types::Document::from({
7323                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7324                            out.insert("name".to_string(), "sigv4".to_string().into());
7325                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7326                            out.insert("signingRegion".to_string(), "me-south-1".to_string().into());
7327                            out.insert("disableDoubleEncoding".to_string(), true.into());
7328                            out
7329                        })
7330                    ]
7331                )
7332                .build()
7333        );
7334    }
7335
7336    /// S3 Outposts bucketAlias Real Outpost Beta
7337    #[test]
7338    fn test_264() {
7339        let params = crate::config::endpoint::Params::builder()
7340            .region("us-east-1".to_string())
7341            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
7342            .endpoint("https://example.amazonaws.com".to_string())
7343            .use_fips(false)
7344            .use_dual_stack(false)
7345            .accelerate(false)
7346            .build()
7347            .expect("invalid params");
7348        let resolver = crate::config::endpoint::DefaultResolver::new();
7349        let endpoint = resolver.resolve_endpoint(&params);
7350        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3.op-0b1d075431d83bebd.example.amazonaws.com");
7351        assert_eq!(
7352            endpoint,
7353            ::aws_smithy_types::endpoint::Endpoint::builder()
7354                .url("https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3.op-0b1d075431d83bebd.example.amazonaws.com")
7355                .property(
7356                    "authSchemes",
7357                    vec![
7358                        ::aws_smithy_types::Document::from({
7359                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7360                            out.insert("name".to_string(), "sigv4a".to_string().into());
7361                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7362                            out.insert(
7363                                "signingRegionSet".to_string(),
7364                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
7365                            );
7366                            out.insert("disableDoubleEncoding".to_string(), true.into());
7367                            out
7368                        }),
7369                        ::aws_smithy_types::Document::from({
7370                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7371                            out.insert("name".to_string(), "sigv4".to_string().into());
7372                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7373                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7374                            out.insert("disableDoubleEncoding".to_string(), true.into());
7375                            out
7376                        })
7377                    ]
7378                )
7379                .build()
7380        );
7381    }
7382
7383    /// S3 Outposts bucketAlias Ec2 Outpost Beta
7384    #[test]
7385    fn test_265() {
7386        let params = crate::config::endpoint::Params::builder()
7387            .region("us-east-1".to_string())
7388            .bucket("161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3".to_string())
7389            .endpoint("https://example.amazonaws.com".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
7398            .expect("Expected valid endpoint: https://161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3.ec2.example.amazonaws.com");
7399        assert_eq!(
7400            endpoint,
7401            ::aws_smithy_types::endpoint::Endpoint::builder()
7402                .url("https://161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3.ec2.example.amazonaws.com")
7403                .property(
7404                    "authSchemes",
7405                    vec![
7406                        ::aws_smithy_types::Document::from({
7407                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7408                            out.insert("name".to_string(), "sigv4a".to_string().into());
7409                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7410                            out.insert(
7411                                "signingRegionSet".to_string(),
7412                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
7413                            );
7414                            out.insert("disableDoubleEncoding".to_string(), true.into());
7415                            out
7416                        }),
7417                        ::aws_smithy_types::Document::from({
7418                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7419                            out.insert("name".to_string(), "sigv4".to_string().into());
7420                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7421                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7422                            out.insert("disableDoubleEncoding".to_string(), true.into());
7423                            out
7424                        })
7425                    ]
7426                )
7427                .build()
7428        );
7429    }
7430
7431    /// S3 Outposts bucketAlias - No endpoint set for beta
7432    #[test]
7433    fn test_266() {
7434        let params = crate::config::endpoint::Params::builder()
7435            .region("us-east-1".to_string())
7436            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
7437            .use_fips(false)
7438            .use_dual_stack(false)
7439            .accelerate(false)
7440            .build()
7441            .expect("invalid params");
7442        let resolver = crate::config::endpoint::DefaultResolver::new();
7443        let endpoint = resolver.resolve_endpoint(&params);
7444        let error = endpoint.expect_err(
7445            "expected error: Expected a endpoint to be specified but no endpoint was found [S3 Outposts bucketAlias - No endpoint set for beta]",
7446        );
7447        assert_eq!(format!("{}", error), "Expected a endpoint to be specified but no endpoint was found")
7448    }
7449
7450    /// S3 Outposts bucketAlias Invalid hardware type
7451    #[test]
7452    fn test_267() {
7453        let params = crate::config::endpoint::Params::builder()
7454            .region("us-east-1".to_string())
7455            .bucket("test-accessp-h0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7456            .use_fips(false)
7457            .use_dual_stack(false)
7458            .accelerate(false)
7459            .build()
7460            .expect("invalid params");
7461        let resolver = crate::config::endpoint::DefaultResolver::new();
7462        let endpoint = resolver.resolve_endpoint(&params);
7463        let error = endpoint.expect_err(
7464            "expected error: Unrecognized hardware type: \"Expected hardware type o or e but got h\" [S3 Outposts bucketAlias Invalid hardware type]",
7465        );
7466        assert_eq!(
7467            format!("{}", error),
7468            "Unrecognized hardware type: \"Expected hardware type o or e but got h\""
7469        )
7470    }
7471
7472    /// S3 Outposts bucketAlias Special character in Outpost Arn
7473    #[test]
7474    fn test_268() {
7475        let params = crate::config::endpoint::Params::builder()
7476            .region("us-east-1".to_string())
7477            .bucket("test-accessp-o00000754%1d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7478            .use_fips(false)
7479            .use_dual_stack(false)
7480            .accelerate(false)
7481            .build()
7482            .expect("invalid params");
7483        let resolver = crate::config::endpoint::DefaultResolver::new();
7484        let endpoint = resolver.resolve_endpoint(&params);
7485        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]");
7486        assert_eq!(
7487            format!("{}", error),
7488            "Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`."
7489        )
7490    }
7491
7492    /// S3 Outposts bucketAlias - No endpoint set for beta
7493    #[test]
7494    fn test_269() {
7495        let params = crate::config::endpoint::Params::builder()
7496            .region("us-east-1".to_string())
7497            .bucket("test-accessp-e0b1d075431d83bebde8xz5w8ijx1qzlbp3i3ebeta0--op-s3".to_string())
7498            .use_fips(false)
7499            .use_dual_stack(false)
7500            .accelerate(false)
7501            .build()
7502            .expect("invalid params");
7503        let resolver = crate::config::endpoint::DefaultResolver::new();
7504        let endpoint = resolver.resolve_endpoint(&params);
7505        let error = endpoint.expect_err(
7506            "expected error: Expected a endpoint to be specified but no endpoint was found [S3 Outposts bucketAlias - No endpoint set for beta]",
7507        );
7508        assert_eq!(format!("{}", error), "Expected a endpoint to be specified but no endpoint was found")
7509    }
7510
7511    /// S3 Snow with bucket
7512    #[test]
7513    fn test_270() {
7514        let params = crate::config::endpoint::Params::builder()
7515            .region("snow".to_string())
7516            .bucket("bucketName".to_string())
7517            .endpoint("http://10.0.1.12:433".to_string())
7518            .use_fips(false)
7519            .use_dual_stack(false)
7520            .accelerate(false)
7521            .build()
7522            .expect("invalid params");
7523        let resolver = crate::config::endpoint::DefaultResolver::new();
7524        let endpoint = resolver.resolve_endpoint(&params);
7525        let endpoint = endpoint.expect("Expected valid endpoint: http://10.0.1.12:433/bucketName");
7526        assert_eq!(
7527            endpoint,
7528            ::aws_smithy_types::endpoint::Endpoint::builder()
7529                .url("http://10.0.1.12:433/bucketName")
7530                .property(
7531                    "authSchemes",
7532                    vec![::aws_smithy_types::Document::from({
7533                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7534                        out.insert("name".to_string(), "sigv4".to_string().into());
7535                        out.insert("signingName".to_string(), "s3".to_string().into());
7536                        out.insert("signingRegion".to_string(), "snow".to_string().into());
7537                        out.insert("disableDoubleEncoding".to_string(), true.into());
7538                        out
7539                    })]
7540                )
7541                .build()
7542        );
7543    }
7544
7545    /// S3 Snow without bucket
7546    #[test]
7547    fn test_271() {
7548        let params = crate::config::endpoint::Params::builder()
7549            .region("snow".to_string())
7550            .endpoint("https://10.0.1.12:433".to_string())
7551            .use_fips(false)
7552            .use_dual_stack(false)
7553            .accelerate(false)
7554            .build()
7555            .expect("invalid params");
7556        let resolver = crate::config::endpoint::DefaultResolver::new();
7557        let endpoint = resolver.resolve_endpoint(&params);
7558        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.1.12:433");
7559        assert_eq!(
7560            endpoint,
7561            ::aws_smithy_types::endpoint::Endpoint::builder()
7562                .url("https://10.0.1.12:433")
7563                .property(
7564                    "authSchemes",
7565                    vec![::aws_smithy_types::Document::from({
7566                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7567                        out.insert("name".to_string(), "sigv4".to_string().into());
7568                        out.insert("signingName".to_string(), "s3".to_string().into());
7569                        out.insert("signingRegion".to_string(), "snow".to_string().into());
7570                        out.insert("disableDoubleEncoding".to_string(), true.into());
7571                        out
7572                    })]
7573                )
7574                .build()
7575        );
7576    }
7577
7578    /// S3 Snow no port
7579    #[test]
7580    fn test_272() {
7581        let params = crate::config::endpoint::Params::builder()
7582            .region("snow".to_string())
7583            .bucket("bucketName".to_string())
7584            .endpoint("http://10.0.1.12".to_string())
7585            .use_fips(false)
7586            .use_dual_stack(false)
7587            .accelerate(false)
7588            .build()
7589            .expect("invalid params");
7590        let resolver = crate::config::endpoint::DefaultResolver::new();
7591        let endpoint = resolver.resolve_endpoint(&params);
7592        let endpoint = endpoint.expect("Expected valid endpoint: http://10.0.1.12/bucketName");
7593        assert_eq!(
7594            endpoint,
7595            ::aws_smithy_types::endpoint::Endpoint::builder()
7596                .url("http://10.0.1.12/bucketName")
7597                .property(
7598                    "authSchemes",
7599                    vec![::aws_smithy_types::Document::from({
7600                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7601                        out.insert("name".to_string(), "sigv4".to_string().into());
7602                        out.insert("signingName".to_string(), "s3".to_string().into());
7603                        out.insert("signingRegion".to_string(), "snow".to_string().into());
7604                        out.insert("disableDoubleEncoding".to_string(), true.into());
7605                        out
7606                    })]
7607                )
7608                .build()
7609        );
7610    }
7611
7612    /// S3 Snow dns endpoint
7613    #[test]
7614    fn test_273() {
7615        let params = crate::config::endpoint::Params::builder()
7616            .region("snow".to_string())
7617            .bucket("bucketName".to_string())
7618            .endpoint("https://amazonaws.com".to_string())
7619            .use_fips(false)
7620            .use_dual_stack(false)
7621            .accelerate(false)
7622            .build()
7623            .expect("invalid params");
7624        let resolver = crate::config::endpoint::DefaultResolver::new();
7625        let endpoint = resolver.resolve_endpoint(&params);
7626        let endpoint = endpoint.expect("Expected valid endpoint: https://amazonaws.com/bucketName");
7627        assert_eq!(
7628            endpoint,
7629            ::aws_smithy_types::endpoint::Endpoint::builder()
7630                .url("https://amazonaws.com/bucketName")
7631                .property(
7632                    "authSchemes",
7633                    vec![::aws_smithy_types::Document::from({
7634                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7635                        out.insert("name".to_string(), "sigv4".to_string().into());
7636                        out.insert("signingName".to_string(), "s3".to_string().into());
7637                        out.insert("signingRegion".to_string(), "snow".to_string().into());
7638                        out.insert("disableDoubleEncoding".to_string(), true.into());
7639                        out
7640                    })]
7641                )
7642                .build()
7643        );
7644    }
7645
7646    /// Data Plane with short AZ
7647    #[test]
7648    fn test_274() {
7649        let params = crate::config::endpoint::Params::builder()
7650            .region("us-east-1".to_string())
7651            .bucket("mybucket--use1-az1--x-s3".to_string())
7652            .use_fips(false)
7653            .use_dual_stack(false)
7654            .accelerate(false)
7655            .use_s3_express_control_endpoint(false)
7656            .build()
7657            .expect("invalid params");
7658        let resolver = crate::config::endpoint::DefaultResolver::new();
7659        let endpoint = resolver.resolve_endpoint(&params);
7660        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--use1-az1--x-s3.s3express-use1-az1.us-east-1.amazonaws.com");
7661        assert_eq!(
7662            endpoint,
7663            ::aws_smithy_types::endpoint::Endpoint::builder()
7664                .url("https://mybucket--use1-az1--x-s3.s3express-use1-az1.us-east-1.amazonaws.com")
7665                .property(
7666                    "authSchemes",
7667                    vec![::aws_smithy_types::Document::from({
7668                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7669                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7670                        out.insert("signingName".to_string(), "s3express".to_string().into());
7671                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7672                        out.insert("disableDoubleEncoding".to_string(), true.into());
7673                        out
7674                    })]
7675                )
7676                .property("backend", "S3Express".to_string())
7677                .build()
7678        );
7679    }
7680
7681    /// Data Plane with short AZ fips
7682    #[test]
7683    fn test_275() {
7684        let params = crate::config::endpoint::Params::builder()
7685            .region("us-east-1".to_string())
7686            .bucket("mybucket--use1-az1--x-s3".to_string())
7687            .use_fips(true)
7688            .use_dual_stack(false)
7689            .accelerate(false)
7690            .use_s3_express_control_endpoint(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: https://mybucket--use1-az1--x-s3.s3express-fips-use1-az1.us-east-1.amazonaws.com");
7696        assert_eq!(
7697            endpoint,
7698            ::aws_smithy_types::endpoint::Endpoint::builder()
7699                .url("https://mybucket--use1-az1--x-s3.s3express-fips-use1-az1.us-east-1.amazonaws.com")
7700                .property(
7701                    "authSchemes",
7702                    vec![::aws_smithy_types::Document::from({
7703                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7704                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7705                        out.insert("signingName".to_string(), "s3express".to_string().into());
7706                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7707                        out.insert("disableDoubleEncoding".to_string(), true.into());
7708                        out
7709                    })]
7710                )
7711                .property("backend", "S3Express".to_string())
7712                .build()
7713        );
7714    }
7715
7716    /// Data Plane with long AZ
7717    #[test]
7718    fn test_276() {
7719        let params = crate::config::endpoint::Params::builder()
7720            .region("ap-northeast-1".to_string())
7721            .bucket("mybucket--apne1-az1--x-s3".to_string())
7722            .use_fips(false)
7723            .use_dual_stack(false)
7724            .accelerate(false)
7725            .use_s3_express_control_endpoint(false)
7726            .build()
7727            .expect("invalid params");
7728        let resolver = crate::config::endpoint::DefaultResolver::new();
7729        let endpoint = resolver.resolve_endpoint(&params);
7730        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--apne1-az1--x-s3.s3express-apne1-az1.ap-northeast-1.amazonaws.com");
7731        assert_eq!(
7732            endpoint,
7733            ::aws_smithy_types::endpoint::Endpoint::builder()
7734                .url("https://mybucket--apne1-az1--x-s3.s3express-apne1-az1.ap-northeast-1.amazonaws.com")
7735                .property(
7736                    "authSchemes",
7737                    vec![::aws_smithy_types::Document::from({
7738                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7739                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7740                        out.insert("signingName".to_string(), "s3express".to_string().into());
7741                        out.insert("signingRegion".to_string(), "ap-northeast-1".to_string().into());
7742                        out.insert("disableDoubleEncoding".to_string(), true.into());
7743                        out
7744                    })]
7745                )
7746                .property("backend", "S3Express".to_string())
7747                .build()
7748        );
7749    }
7750
7751    /// Data Plane with long AZ fips
7752    #[test]
7753    fn test_277() {
7754        let params = crate::config::endpoint::Params::builder()
7755            .region("ap-northeast-1".to_string())
7756            .bucket("mybucket--apne1-az1--x-s3".to_string())
7757            .use_fips(true)
7758            .use_dual_stack(false)
7759            .accelerate(false)
7760            .use_s3_express_control_endpoint(false)
7761            .build()
7762            .expect("invalid params");
7763        let resolver = crate::config::endpoint::DefaultResolver::new();
7764        let endpoint = resolver.resolve_endpoint(&params);
7765        let endpoint =
7766            endpoint.expect("Expected valid endpoint: https://mybucket--apne1-az1--x-s3.s3express-fips-apne1-az1.ap-northeast-1.amazonaws.com");
7767        assert_eq!(
7768            endpoint,
7769            ::aws_smithy_types::endpoint::Endpoint::builder()
7770                .url("https://mybucket--apne1-az1--x-s3.s3express-fips-apne1-az1.ap-northeast-1.amazonaws.com")
7771                .property(
7772                    "authSchemes",
7773                    vec![::aws_smithy_types::Document::from({
7774                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7775                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7776                        out.insert("signingName".to_string(), "s3express".to_string().into());
7777                        out.insert("signingRegion".to_string(), "ap-northeast-1".to_string().into());
7778                        out.insert("disableDoubleEncoding".to_string(), true.into());
7779                        out
7780                    })]
7781                )
7782                .property("backend", "S3Express".to_string())
7783                .build()
7784        );
7785    }
7786
7787    /// Control plane with short AZ bucket
7788    #[test]
7789    fn test_278() {
7790        let params = crate::config::endpoint::Params::builder()
7791            .region("us-east-1".to_string())
7792            .bucket("mybucket--use1-az1--x-s3".to_string())
7793            .use_fips(false)
7794            .use_dual_stack(false)
7795            .accelerate(false)
7796            .use_s3_express_control_endpoint(true)
7797            .disable_s3_express_session_auth(false)
7798            .build()
7799            .expect("invalid params");
7800        let resolver = crate::config::endpoint::DefaultResolver::new();
7801        let endpoint = resolver.resolve_endpoint(&params);
7802        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com/mybucket--use1-az1--x-s3");
7803        assert_eq!(
7804            endpoint,
7805            ::aws_smithy_types::endpoint::Endpoint::builder()
7806                .url("https://s3express-control.us-east-1.amazonaws.com/mybucket--use1-az1--x-s3")
7807                .property(
7808                    "authSchemes",
7809                    vec![::aws_smithy_types::Document::from({
7810                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7811                        out.insert("name".to_string(), "sigv4".to_string().into());
7812                        out.insert("signingName".to_string(), "s3express".to_string().into());
7813                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7814                        out.insert("disableDoubleEncoding".to_string(), true.into());
7815                        out
7816                    })]
7817                )
7818                .property("backend", "S3Express".to_string())
7819                .build()
7820        );
7821    }
7822
7823    /// Control plane with short AZ bucket and fips
7824    #[test]
7825    fn test_279() {
7826        let params = crate::config::endpoint::Params::builder()
7827            .region("us-east-1".to_string())
7828            .bucket("mybucket--use1-az1--x-s3".to_string())
7829            .use_fips(true)
7830            .use_dual_stack(false)
7831            .accelerate(false)
7832            .use_s3_express_control_endpoint(true)
7833            .disable_s3_express_session_auth(false)
7834            .build()
7835            .expect("invalid params");
7836        let resolver = crate::config::endpoint::DefaultResolver::new();
7837        let endpoint = resolver.resolve_endpoint(&params);
7838        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--use1-az1--x-s3");
7839        assert_eq!(
7840            endpoint,
7841            ::aws_smithy_types::endpoint::Endpoint::builder()
7842                .url("https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--use1-az1--x-s3")
7843                .property(
7844                    "authSchemes",
7845                    vec![::aws_smithy_types::Document::from({
7846                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7847                        out.insert("name".to_string(), "sigv4".to_string().into());
7848                        out.insert("signingName".to_string(), "s3express".to_string().into());
7849                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7850                        out.insert("disableDoubleEncoding".to_string(), true.into());
7851                        out
7852                    })]
7853                )
7854                .property("backend", "S3Express".to_string())
7855                .build()
7856        );
7857    }
7858
7859    /// Control plane without bucket
7860    #[test]
7861    fn test_280() {
7862        let params = crate::config::endpoint::Params::builder()
7863            .region("us-east-1".to_string())
7864            .use_fips(false)
7865            .use_dual_stack(false)
7866            .accelerate(false)
7867            .use_s3_express_control_endpoint(true)
7868            .disable_s3_express_session_auth(false)
7869            .build()
7870            .expect("invalid params");
7871        let resolver = crate::config::endpoint::DefaultResolver::new();
7872        let endpoint = resolver.resolve_endpoint(&params);
7873        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com");
7874        assert_eq!(
7875            endpoint,
7876            ::aws_smithy_types::endpoint::Endpoint::builder()
7877                .url("https://s3express-control.us-east-1.amazonaws.com")
7878                .property(
7879                    "authSchemes",
7880                    vec![::aws_smithy_types::Document::from({
7881                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7882                        out.insert("name".to_string(), "sigv4".to_string().into());
7883                        out.insert("signingName".to_string(), "s3express".to_string().into());
7884                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7885                        out.insert("disableDoubleEncoding".to_string(), true.into());
7886                        out
7887                    })]
7888                )
7889                .property("backend", "S3Express".to_string())
7890                .build()
7891        );
7892    }
7893
7894    /// Control plane without bucket and fips
7895    #[test]
7896    fn test_281() {
7897        let params = crate::config::endpoint::Params::builder()
7898            .region("us-east-1".to_string())
7899            .use_fips(true)
7900            .use_dual_stack(false)
7901            .accelerate(false)
7902            .use_s3_express_control_endpoint(true)
7903            .disable_s3_express_session_auth(false)
7904            .build()
7905            .expect("invalid params");
7906        let resolver = crate::config::endpoint::DefaultResolver::new();
7907        let endpoint = resolver.resolve_endpoint(&params);
7908        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com");
7909        assert_eq!(
7910            endpoint,
7911            ::aws_smithy_types::endpoint::Endpoint::builder()
7912                .url("https://s3express-control-fips.us-east-1.amazonaws.com")
7913                .property(
7914                    "authSchemes",
7915                    vec![::aws_smithy_types::Document::from({
7916                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7917                        out.insert("name".to_string(), "sigv4".to_string().into());
7918                        out.insert("signingName".to_string(), "s3express".to_string().into());
7919                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7920                        out.insert("disableDoubleEncoding".to_string(), true.into());
7921                        out
7922                    })]
7923                )
7924                .property("backend", "S3Express".to_string())
7925                .build()
7926        );
7927    }
7928
7929    /// Data Plane sigv4 auth with short AZ
7930    #[test]
7931    fn test_282() {
7932        let params = crate::config::endpoint::Params::builder()
7933            .region("us-west-2".to_string())
7934            .bucket("mybucket--usw2-az1--x-s3".to_string())
7935            .use_fips(false)
7936            .use_dual_stack(false)
7937            .accelerate(false)
7938            .disable_s3_express_session_auth(true)
7939            .build()
7940            .expect("invalid params");
7941        let resolver = crate::config::endpoint::DefaultResolver::new();
7942        let endpoint = resolver.resolve_endpoint(&params);
7943        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com");
7944        assert_eq!(
7945            endpoint,
7946            ::aws_smithy_types::endpoint::Endpoint::builder()
7947                .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com")
7948                .property(
7949                    "authSchemes",
7950                    vec![::aws_smithy_types::Document::from({
7951                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7952                        out.insert("name".to_string(), "sigv4".to_string().into());
7953                        out.insert("signingName".to_string(), "s3express".to_string().into());
7954                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7955                        out.insert("disableDoubleEncoding".to_string(), true.into());
7956                        out
7957                    })]
7958                )
7959                .property("backend", "S3Express".to_string())
7960                .build()
7961        );
7962    }
7963
7964    /// Data Plane sigv4 auth with short AZ fips
7965    #[test]
7966    fn test_283() {
7967        let params = crate::config::endpoint::Params::builder()
7968            .region("us-west-2".to_string())
7969            .bucket("mybucket--usw2-az1--x-s3".to_string())
7970            .use_fips(true)
7971            .use_dual_stack(false)
7972            .accelerate(false)
7973            .disable_s3_express_session_auth(true)
7974            .build()
7975            .expect("invalid params");
7976        let resolver = crate::config::endpoint::DefaultResolver::new();
7977        let endpoint = resolver.resolve_endpoint(&params);
7978        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com");
7979        assert_eq!(
7980            endpoint,
7981            ::aws_smithy_types::endpoint::Endpoint::builder()
7982                .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com")
7983                .property(
7984                    "authSchemes",
7985                    vec![::aws_smithy_types::Document::from({
7986                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7987                        out.insert("name".to_string(), "sigv4".to_string().into());
7988                        out.insert("signingName".to_string(), "s3express".to_string().into());
7989                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7990                        out.insert("disableDoubleEncoding".to_string(), true.into());
7991                        out
7992                    })]
7993                )
7994                .property("backend", "S3Express".to_string())
7995                .build()
7996        );
7997    }
7998
7999    /// Data Plane sigv4 auth with long AZ
8000    #[test]
8001    fn test_284() {
8002        let params = crate::config::endpoint::Params::builder()
8003            .region("ap-northeast-1".to_string())
8004            .bucket("mybucket--apne1-az1--x-s3".to_string())
8005            .use_fips(false)
8006            .use_dual_stack(false)
8007            .accelerate(false)
8008            .use_s3_express_control_endpoint(false)
8009            .disable_s3_express_session_auth(true)
8010            .build()
8011            .expect("invalid params");
8012        let resolver = crate::config::endpoint::DefaultResolver::new();
8013        let endpoint = resolver.resolve_endpoint(&params);
8014        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--apne1-az1--x-s3.s3express-apne1-az1.ap-northeast-1.amazonaws.com");
8015        assert_eq!(
8016            endpoint,
8017            ::aws_smithy_types::endpoint::Endpoint::builder()
8018                .url("https://mybucket--apne1-az1--x-s3.s3express-apne1-az1.ap-northeast-1.amazonaws.com")
8019                .property(
8020                    "authSchemes",
8021                    vec![::aws_smithy_types::Document::from({
8022                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8023                        out.insert("name".to_string(), "sigv4".to_string().into());
8024                        out.insert("signingName".to_string(), "s3express".to_string().into());
8025                        out.insert("signingRegion".to_string(), "ap-northeast-1".to_string().into());
8026                        out.insert("disableDoubleEncoding".to_string(), true.into());
8027                        out
8028                    })]
8029                )
8030                .property("backend", "S3Express".to_string())
8031                .build()
8032        );
8033    }
8034
8035    /// Data Plane sigv4 auth with long AZ fips
8036    #[test]
8037    fn test_285() {
8038        let params = crate::config::endpoint::Params::builder()
8039            .region("ap-northeast-1".to_string())
8040            .bucket("mybucket--apne1-az1--x-s3".to_string())
8041            .use_fips(true)
8042            .use_dual_stack(false)
8043            .accelerate(false)
8044            .use_s3_express_control_endpoint(false)
8045            .disable_s3_express_session_auth(true)
8046            .build()
8047            .expect("invalid params");
8048        let resolver = crate::config::endpoint::DefaultResolver::new();
8049        let endpoint = resolver.resolve_endpoint(&params);
8050        let endpoint =
8051            endpoint.expect("Expected valid endpoint: https://mybucket--apne1-az1--x-s3.s3express-fips-apne1-az1.ap-northeast-1.amazonaws.com");
8052        assert_eq!(
8053            endpoint,
8054            ::aws_smithy_types::endpoint::Endpoint::builder()
8055                .url("https://mybucket--apne1-az1--x-s3.s3express-fips-apne1-az1.ap-northeast-1.amazonaws.com")
8056                .property(
8057                    "authSchemes",
8058                    vec![::aws_smithy_types::Document::from({
8059                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8060                        out.insert("name".to_string(), "sigv4".to_string().into());
8061                        out.insert("signingName".to_string(), "s3express".to_string().into());
8062                        out.insert("signingRegion".to_string(), "ap-northeast-1".to_string().into());
8063                        out.insert("disableDoubleEncoding".to_string(), true.into());
8064                        out
8065                    })]
8066                )
8067                .property("backend", "S3Express".to_string())
8068                .build()
8069        );
8070    }
8071
8072    /// Control Plane host override
8073    #[test]
8074    fn test_286() {
8075        let params = crate::config::endpoint::Params::builder()
8076            .region("us-west-2".to_string())
8077            .bucket("mybucket--usw2-az1--x-s3".to_string())
8078            .use_fips(false)
8079            .use_dual_stack(false)
8080            .accelerate(false)
8081            .use_s3_express_control_endpoint(true)
8082            .disable_s3_express_session_auth(true)
8083            .endpoint("https://custom.com".to_string())
8084            .build()
8085            .expect("invalid params");
8086        let resolver = crate::config::endpoint::DefaultResolver::new();
8087        let endpoint = resolver.resolve_endpoint(&params);
8088        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
8089        assert_eq!(
8090            endpoint,
8091            ::aws_smithy_types::endpoint::Endpoint::builder()
8092                .url("https://mybucket--usw2-az1--x-s3.custom.com")
8093                .property(
8094                    "authSchemes",
8095                    vec![::aws_smithy_types::Document::from({
8096                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8097                        out.insert("name".to_string(), "sigv4".to_string().into());
8098                        out.insert("signingName".to_string(), "s3express".to_string().into());
8099                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8100                        out.insert("disableDoubleEncoding".to_string(), true.into());
8101                        out
8102                    })]
8103                )
8104                .property("backend", "S3Express".to_string())
8105                .build()
8106        );
8107    }
8108
8109    /// Control Plane host override no bucket
8110    #[test]
8111    fn test_287() {
8112        let params = crate::config::endpoint::Params::builder()
8113            .region("us-west-2".to_string())
8114            .use_fips(false)
8115            .use_dual_stack(false)
8116            .accelerate(false)
8117            .use_s3_express_control_endpoint(true)
8118            .disable_s3_express_session_auth(true)
8119            .endpoint("https://custom.com".to_string())
8120            .build()
8121            .expect("invalid params");
8122        let resolver = crate::config::endpoint::DefaultResolver::new();
8123        let endpoint = resolver.resolve_endpoint(&params);
8124        let endpoint = endpoint.expect("Expected valid endpoint: https://custom.com");
8125        assert_eq!(
8126            endpoint,
8127            ::aws_smithy_types::endpoint::Endpoint::builder()
8128                .url("https://custom.com")
8129                .property(
8130                    "authSchemes",
8131                    vec![::aws_smithy_types::Document::from({
8132                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8133                        out.insert("name".to_string(), "sigv4".to_string().into());
8134                        out.insert("signingName".to_string(), "s3express".to_string().into());
8135                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8136                        out.insert("disableDoubleEncoding".to_string(), true.into());
8137                        out
8138                    })]
8139                )
8140                .property("backend", "S3Express".to_string())
8141                .build()
8142        );
8143    }
8144
8145    /// Data plane host override non virtual session auth
8146    #[test]
8147    fn test_288() {
8148        let params = crate::config::endpoint::Params::builder()
8149            .region("us-west-2".to_string())
8150            .bucket("mybucket--usw2-az1--x-s3".to_string())
8151            .use_fips(false)
8152            .use_dual_stack(false)
8153            .accelerate(false)
8154            .endpoint("https://10.0.0.1".to_string())
8155            .build()
8156            .expect("invalid params");
8157        let resolver = crate::config::endpoint::DefaultResolver::new();
8158        let endpoint = resolver.resolve_endpoint(&params);
8159        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
8160        assert_eq!(
8161            endpoint,
8162            ::aws_smithy_types::endpoint::Endpoint::builder()
8163                .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
8164                .property(
8165                    "authSchemes",
8166                    vec![::aws_smithy_types::Document::from({
8167                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8168                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8169                        out.insert("signingName".to_string(), "s3express".to_string().into());
8170                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8171                        out.insert("disableDoubleEncoding".to_string(), true.into());
8172                        out
8173                    })]
8174                )
8175                .property("backend", "S3Express".to_string())
8176                .build()
8177        );
8178    }
8179
8180    /// Control Plane host override ip
8181    #[test]
8182    fn test_289() {
8183        let params = crate::config::endpoint::Params::builder()
8184            .region("us-west-2".to_string())
8185            .bucket("mybucket--usw2-az1--x-s3".to_string())
8186            .use_fips(false)
8187            .use_dual_stack(false)
8188            .accelerate(false)
8189            .use_s3_express_control_endpoint(true)
8190            .disable_s3_express_session_auth(true)
8191            .endpoint("https://10.0.0.1".to_string())
8192            .build()
8193            .expect("invalid params");
8194        let resolver = crate::config::endpoint::DefaultResolver::new();
8195        let endpoint = resolver.resolve_endpoint(&params);
8196        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
8197        assert_eq!(
8198            endpoint,
8199            ::aws_smithy_types::endpoint::Endpoint::builder()
8200                .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
8201                .property(
8202                    "authSchemes",
8203                    vec![::aws_smithy_types::Document::from({
8204                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8205                        out.insert("name".to_string(), "sigv4".to_string().into());
8206                        out.insert("signingName".to_string(), "s3express".to_string().into());
8207                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8208                        out.insert("disableDoubleEncoding".to_string(), true.into());
8209                        out
8210                    })]
8211                )
8212                .property("backend", "S3Express".to_string())
8213                .build()
8214        );
8215    }
8216
8217    /// Data plane host override
8218    #[test]
8219    fn test_290() {
8220        let params = crate::config::endpoint::Params::builder()
8221            .region("us-west-2".to_string())
8222            .bucket("mybucket--usw2-az1--x-s3".to_string())
8223            .use_fips(false)
8224            .use_dual_stack(false)
8225            .accelerate(false)
8226            .endpoint("https://custom.com".to_string())
8227            .build()
8228            .expect("invalid params");
8229        let resolver = crate::config::endpoint::DefaultResolver::new();
8230        let endpoint = resolver.resolve_endpoint(&params);
8231        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
8232        assert_eq!(
8233            endpoint,
8234            ::aws_smithy_types::endpoint::Endpoint::builder()
8235                .url("https://mybucket--usw2-az1--x-s3.custom.com")
8236                .property(
8237                    "authSchemes",
8238                    vec![::aws_smithy_types::Document::from({
8239                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8240                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8241                        out.insert("signingName".to_string(), "s3express".to_string().into());
8242                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8243                        out.insert("disableDoubleEncoding".to_string(), true.into());
8244                        out
8245                    })]
8246                )
8247                .property("backend", "S3Express".to_string())
8248                .build()
8249        );
8250    }
8251
8252    /// bad format error
8253    #[test]
8254    fn test_291() {
8255        let params = crate::config::endpoint::Params::builder()
8256            .region("us-east-1".to_string())
8257            .bucket("mybucket--usaz1--x-s3".to_string())
8258            .use_fips(false)
8259            .use_dual_stack(false)
8260            .accelerate(false)
8261            .use_s3_express_control_endpoint(false)
8262            .build()
8263            .expect("invalid params");
8264        let resolver = crate::config::endpoint::DefaultResolver::new();
8265        let endpoint = resolver.resolve_endpoint(&params);
8266        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad format error]");
8267        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
8268    }
8269
8270    /// bad format error no session auth
8271    #[test]
8272    fn test_292() {
8273        let params = crate::config::endpoint::Params::builder()
8274            .region("us-east-1".to_string())
8275            .bucket("mybucket--usaz1--x-s3".to_string())
8276            .use_fips(false)
8277            .use_dual_stack(false)
8278            .accelerate(false)
8279            .use_s3_express_control_endpoint(false)
8280            .disable_s3_express_session_auth(true)
8281            .build()
8282            .expect("invalid params");
8283        let resolver = crate::config::endpoint::DefaultResolver::new();
8284        let endpoint = resolver.resolve_endpoint(&params);
8285        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad format error no session auth]");
8286        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
8287    }
8288
8289    /// dual-stack error
8290    #[test]
8291    fn test_293() {
8292        let params = crate::config::endpoint::Params::builder()
8293            .region("us-east-1".to_string())
8294            .bucket("mybucket--use1-az1--x-s3".to_string())
8295            .use_fips(false)
8296            .use_dual_stack(true)
8297            .accelerate(false)
8298            .use_s3_express_control_endpoint(false)
8299            .build()
8300            .expect("invalid params");
8301        let resolver = crate::config::endpoint::DefaultResolver::new();
8302        let endpoint = resolver.resolve_endpoint(&params);
8303        let error = endpoint.expect_err("expected error: S3Express does not support Dual-stack. [dual-stack error]");
8304        assert_eq!(format!("{}", error), "S3Express does not support Dual-stack.")
8305    }
8306
8307    /// accelerate error
8308    #[test]
8309    fn test_294() {
8310        let params = crate::config::endpoint::Params::builder()
8311            .region("us-east-1".to_string())
8312            .bucket("mybucket--use1-az1--x-s3".to_string())
8313            .use_fips(false)
8314            .use_dual_stack(false)
8315            .accelerate(true)
8316            .use_s3_express_control_endpoint(false)
8317            .build()
8318            .expect("invalid params");
8319        let resolver = crate::config::endpoint::DefaultResolver::new();
8320        let endpoint = resolver.resolve_endpoint(&params);
8321        let error = endpoint.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error]");
8322        assert_eq!(format!("{}", error), "S3Express does not support S3 Accelerate.")
8323    }
8324
8325    /// Data plane bucket format error
8326    #[test]
8327    fn test_295() {
8328        let params = crate::config::endpoint::Params::builder()
8329            .region("us-east-1".to_string())
8330            .bucket("my.bucket--use1-az1--x-s3".to_string())
8331            .use_fips(false)
8332            .use_dual_stack(false)
8333            .accelerate(false)
8334            .use_s3_express_control_endpoint(false)
8335            .build()
8336            .expect("invalid params");
8337        let resolver = crate::config::endpoint::DefaultResolver::new();
8338        let endpoint = resolver.resolve_endpoint(&params);
8339        let error =
8340            endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane bucket format error]");
8341        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8342    }
8343
8344    /// host override data plane bucket error session auth
8345    #[test]
8346    fn test_296() {
8347        let params = crate::config::endpoint::Params::builder()
8348            .region("us-west-2".to_string())
8349            .bucket("my.bucket--usw2-az1--x-s3".to_string())
8350            .use_fips(false)
8351            .use_dual_stack(false)
8352            .accelerate(false)
8353            .endpoint("https://custom.com".to_string())
8354            .build()
8355            .expect("invalid params");
8356        let resolver = crate::config::endpoint::DefaultResolver::new();
8357        let endpoint = resolver.resolve_endpoint(&params);
8358        let error = endpoint.expect_err(
8359            "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error session auth]",
8360        );
8361        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8362    }
8363
8364    /// host override data plane bucket error
8365    #[test]
8366    fn test_297() {
8367        let params = crate::config::endpoint::Params::builder()
8368            .region("us-west-2".to_string())
8369            .bucket("my.bucket--usw2-az1--x-s3".to_string())
8370            .use_fips(false)
8371            .use_dual_stack(false)
8372            .accelerate(false)
8373            .endpoint("https://custom.com".to_string())
8374            .disable_s3_express_session_auth(true)
8375            .build()
8376            .expect("invalid params");
8377        let resolver = crate::config::endpoint::DefaultResolver::new();
8378        let endpoint = resolver.resolve_endpoint(&params);
8379        let error = endpoint
8380            .expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error]");
8381        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8382    }
8383}
8384
8385/// Endpoint resolver trait specific to Amazon Simple Storage Service
8386pub trait ResolveEndpoint: ::std::marker::Send + ::std::marker::Sync + ::std::fmt::Debug {
8387    /// Resolve an endpoint with the given parameters
8388    fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a>;
8389
8390    /// Convert this service-specific resolver into a `SharedEndpointResolver`
8391    ///
8392    /// The resulting resolver will downcast `EndpointResolverParams` into `crate::config::endpoint::Params`.
8393    fn into_shared_resolver(self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver
8394    where
8395        Self: Sized + 'static,
8396    {
8397        ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
8398    }
8399}
8400
8401#[derive(Debug)]
8402struct DowncastParams<T>(T);
8403impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
8404where
8405    T: ResolveEndpoint,
8406{
8407    fn resolve_endpoint<'a>(
8408        &'a self,
8409        params: &'a ::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams,
8410    ) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
8411        let ep = match params.get::<crate::config::endpoint::Params>() {
8412            Some(params) => self.0.resolve_endpoint(params),
8413            None => ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(Err("params of expected type was not present".into())),
8414        };
8415        ep
8416    }
8417}
8418
8419/// The default endpoint resolver
8420#[derive(Debug, Default)]
8421pub struct DefaultResolver {
8422    partition_resolver: crate::endpoint_lib::partition::PartitionResolver,
8423}
8424
8425impl DefaultResolver {
8426    /// Create a new endpoint resolver with default settings
8427    pub fn new() -> Self {
8428        Self {
8429            partition_resolver: crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER.clone(),
8430        }
8431    }
8432
8433    fn resolve_endpoint(
8434        &self,
8435        params: &crate::config::endpoint::Params,
8436    ) -> Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_runtime_api::box_error::BoxError> {
8437        let mut diagnostic_collector = crate::endpoint_lib::diagnostic::DiagnosticCollector::new();
8438        Ok(
8439            crate::config::endpoint::internals::resolve_endpoint(params, &mut diagnostic_collector, &self.partition_resolver)
8440                .map_err(|err| err.with_source(diagnostic_collector.take_last_error()))?,
8441        )
8442    }
8443}
8444
8445impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
8446    fn resolve_endpoint(&self, params: &crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture {
8447        ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(self.resolve_endpoint(params))
8448    }
8449}
8450
8451#[non_exhaustive]
8452#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
8453/// Configuration parameters for resolving the correct endpoint
8454pub struct Params {
8455    /// 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.
8456    pub(crate) bucket: ::std::option::Option<::std::string::String>,
8457    /// The AWS region used to dispatch the request.
8458    pub(crate) region: ::std::option::Option<::std::string::String>,
8459    /// 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.
8460    pub(crate) use_fips: bool,
8461    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
8462    pub(crate) use_dual_stack: bool,
8463    /// Override the endpoint used to send this request
8464    pub(crate) endpoint: ::std::option::Option<::std::string::String>,
8465    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
8466    pub(crate) force_path_style: bool,
8467    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
8468    pub(crate) accelerate: bool,
8469    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
8470    pub(crate) use_global_endpoint: bool,
8471    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
8472    pub(crate) use_object_lambda_endpoint: ::std::option::Option<bool>,
8473    /// 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.
8474    pub(crate) key: ::std::option::Option<::std::string::String>,
8475    /// 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.
8476    pub(crate) prefix: ::std::option::Option<::std::string::String>,
8477    /// Internal parameter to disable Access Point Buckets
8478    pub(crate) disable_access_points: ::std::option::Option<bool>,
8479    /// Whether multi-region access points (MRAP) should be disabled.
8480    pub(crate) disable_multi_region_access_points: bool,
8481    /// 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.
8482    pub(crate) use_arn_region: ::std::option::Option<bool>,
8483    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
8484    pub(crate) use_s3_express_control_endpoint: ::std::option::Option<bool>,
8485    /// Parameter to indicate whether S3Express session auth should be disabled
8486    pub(crate) disable_s3_express_session_auth: ::std::option::Option<bool>,
8487}
8488impl Params {
8489    /// Create a builder for [`Params`]
8490    pub fn builder() -> crate::config::endpoint::ParamsBuilder {
8491        crate::config::endpoint::ParamsBuilder::default()
8492    }
8493    /// 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.
8494    pub fn bucket(&self) -> ::std::option::Option<&str> {
8495        self.bucket.as_deref()
8496    }
8497    /// The AWS region used to dispatch the request.
8498    pub fn region(&self) -> ::std::option::Option<&str> {
8499        self.region.as_deref()
8500    }
8501    /// 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.
8502    pub fn use_fips(&self) -> ::std::option::Option<bool> {
8503        Some(self.use_fips)
8504    }
8505    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
8506    pub fn use_dual_stack(&self) -> ::std::option::Option<bool> {
8507        Some(self.use_dual_stack)
8508    }
8509    /// Override the endpoint used to send this request
8510    pub fn endpoint(&self) -> ::std::option::Option<&str> {
8511        self.endpoint.as_deref()
8512    }
8513    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
8514    pub fn force_path_style(&self) -> ::std::option::Option<bool> {
8515        Some(self.force_path_style)
8516    }
8517    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
8518    pub fn accelerate(&self) -> ::std::option::Option<bool> {
8519        Some(self.accelerate)
8520    }
8521    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
8522    pub fn use_global_endpoint(&self) -> ::std::option::Option<bool> {
8523        Some(self.use_global_endpoint)
8524    }
8525    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
8526    pub fn use_object_lambda_endpoint(&self) -> ::std::option::Option<bool> {
8527        self.use_object_lambda_endpoint
8528    }
8529    /// 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.
8530    pub fn key(&self) -> ::std::option::Option<&str> {
8531        self.key.as_deref()
8532    }
8533    /// 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.
8534    pub fn prefix(&self) -> ::std::option::Option<&str> {
8535        self.prefix.as_deref()
8536    }
8537    /// Internal parameter to disable Access Point Buckets
8538    pub fn disable_access_points(&self) -> ::std::option::Option<bool> {
8539        self.disable_access_points
8540    }
8541    /// Whether multi-region access points (MRAP) should be disabled.
8542    pub fn disable_multi_region_access_points(&self) -> ::std::option::Option<bool> {
8543        Some(self.disable_multi_region_access_points)
8544    }
8545    /// 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.
8546    pub fn use_arn_region(&self) -> ::std::option::Option<bool> {
8547        self.use_arn_region
8548    }
8549    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
8550    pub fn use_s3_express_control_endpoint(&self) -> ::std::option::Option<bool> {
8551        self.use_s3_express_control_endpoint
8552    }
8553    /// Parameter to indicate whether S3Express session auth should be disabled
8554    pub fn disable_s3_express_session_auth(&self) -> ::std::option::Option<bool> {
8555        self.disable_s3_express_session_auth
8556    }
8557}
8558
8559/// Builder for [`Params`]
8560#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
8561pub struct ParamsBuilder {
8562    bucket: ::std::option::Option<::std::string::String>,
8563    region: ::std::option::Option<::std::string::String>,
8564    use_fips: ::std::option::Option<bool>,
8565    use_dual_stack: ::std::option::Option<bool>,
8566    endpoint: ::std::option::Option<::std::string::String>,
8567    force_path_style: ::std::option::Option<bool>,
8568    accelerate: ::std::option::Option<bool>,
8569    use_global_endpoint: ::std::option::Option<bool>,
8570    use_object_lambda_endpoint: ::std::option::Option<bool>,
8571    key: ::std::option::Option<::std::string::String>,
8572    prefix: ::std::option::Option<::std::string::String>,
8573    disable_access_points: ::std::option::Option<bool>,
8574    disable_multi_region_access_points: ::std::option::Option<bool>,
8575    use_arn_region: ::std::option::Option<bool>,
8576    use_s3_express_control_endpoint: ::std::option::Option<bool>,
8577    disable_s3_express_session_auth: ::std::option::Option<bool>,
8578}
8579impl ParamsBuilder {
8580    /// Consume this builder, creating [`Params`].
8581    pub fn build(self) -> ::std::result::Result<crate::config::endpoint::Params, crate::config::endpoint::InvalidParams> {
8582        Ok(
8583            #[allow(clippy::unnecessary_lazy_evaluations)]
8584            crate::config::endpoint::Params {
8585                bucket: self.bucket,
8586                region: self.region,
8587                use_fips: self
8588                    .use_fips
8589                    .or_else(|| Some(false))
8590                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_fips"))?,
8591                use_dual_stack: self
8592                    .use_dual_stack
8593                    .or_else(|| Some(false))
8594                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_dual_stack"))?,
8595                endpoint: self.endpoint,
8596                force_path_style: self
8597                    .force_path_style
8598                    .or_else(|| Some(false))
8599                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("force_path_style"))?,
8600                accelerate: self
8601                    .accelerate
8602                    .or_else(|| Some(false))
8603                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("accelerate"))?,
8604                use_global_endpoint: self
8605                    .use_global_endpoint
8606                    .or_else(|| Some(false))
8607                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_global_endpoint"))?,
8608                use_object_lambda_endpoint: self.use_object_lambda_endpoint,
8609                key: self.key,
8610                prefix: self.prefix,
8611                disable_access_points: self.disable_access_points,
8612                disable_multi_region_access_points: self
8613                    .disable_multi_region_access_points
8614                    .or_else(|| Some(false))
8615                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("disable_multi_region_access_points"))?,
8616                use_arn_region: self.use_arn_region,
8617                use_s3_express_control_endpoint: self.use_s3_express_control_endpoint,
8618                disable_s3_express_session_auth: self.disable_s3_express_session_auth,
8619            },
8620        )
8621    }
8622    /// Sets the value for bucket
8623    ///
8624    /// 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.
8625    pub fn bucket(mut self, value: impl Into<::std::string::String>) -> Self {
8626        self.bucket = Some(value.into());
8627        self
8628    }
8629
8630    /// Sets the value for bucket
8631    ///
8632    /// 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.
8633    pub fn set_bucket(mut self, param: Option<::std::string::String>) -> Self {
8634        self.bucket = param;
8635        self
8636    }
8637    /// Sets the value for region
8638    ///
8639    /// The AWS region used to dispatch the request.
8640    pub fn region(mut self, value: impl Into<::std::string::String>) -> Self {
8641        self.region = Some(value.into());
8642        self
8643    }
8644
8645    /// Sets the value for region
8646    ///
8647    /// The AWS region used to dispatch the request.
8648    pub fn set_region(mut self, param: Option<::std::string::String>) -> Self {
8649        self.region = param;
8650        self
8651    }
8652    /// Sets the value for use_fips
8653    ///
8654    /// When unset, this parameter has a default value of `false`.
8655    /// 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.
8656    pub fn use_fips(mut self, value: impl Into<bool>) -> Self {
8657        self.use_fips = Some(value.into());
8658        self
8659    }
8660
8661    /// Sets the value for use_fips
8662    ///
8663    /// When unset, this parameter has a default value of `false`.
8664    /// 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.
8665    pub fn set_use_fips(mut self, param: Option<bool>) -> Self {
8666        self.use_fips = param;
8667        self
8668    }
8669    /// Sets the value for use_dual_stack
8670    ///
8671    /// When unset, this parameter has a default value of `false`.
8672    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
8673    pub fn use_dual_stack(mut self, value: impl Into<bool>) -> Self {
8674        self.use_dual_stack = Some(value.into());
8675        self
8676    }
8677
8678    /// Sets the value for use_dual_stack
8679    ///
8680    /// When unset, this parameter has a default value of `false`.
8681    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
8682    pub fn set_use_dual_stack(mut self, param: Option<bool>) -> Self {
8683        self.use_dual_stack = param;
8684        self
8685    }
8686    /// Sets the value for endpoint
8687    ///
8688    /// Override the endpoint used to send this request
8689    pub fn endpoint(mut self, value: impl Into<::std::string::String>) -> Self {
8690        self.endpoint = Some(value.into());
8691        self
8692    }
8693
8694    /// Sets the value for endpoint
8695    ///
8696    /// Override the endpoint used to send this request
8697    pub fn set_endpoint(mut self, param: Option<::std::string::String>) -> Self {
8698        self.endpoint = param;
8699        self
8700    }
8701    /// Sets the value for force_path_style
8702    ///
8703    /// When unset, this parameter has a default value of `false`.
8704    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
8705    pub fn force_path_style(mut self, value: impl Into<bool>) -> Self {
8706        self.force_path_style = Some(value.into());
8707        self
8708    }
8709
8710    /// Sets the value for force_path_style
8711    ///
8712    /// When unset, this parameter has a default value of `false`.
8713    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
8714    pub fn set_force_path_style(mut self, param: Option<bool>) -> Self {
8715        self.force_path_style = param;
8716        self
8717    }
8718    /// Sets the value for accelerate
8719    ///
8720    /// When unset, this parameter has a default value of `false`.
8721    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
8722    pub fn accelerate(mut self, value: impl Into<bool>) -> Self {
8723        self.accelerate = Some(value.into());
8724        self
8725    }
8726
8727    /// Sets the value for accelerate
8728    ///
8729    /// When unset, this parameter has a default value of `false`.
8730    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
8731    pub fn set_accelerate(mut self, param: Option<bool>) -> Self {
8732        self.accelerate = param;
8733        self
8734    }
8735    /// Sets the value for use_global_endpoint
8736    ///
8737    /// When unset, this parameter has a default value of `false`.
8738    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
8739    pub fn use_global_endpoint(mut self, value: impl Into<bool>) -> Self {
8740        self.use_global_endpoint = Some(value.into());
8741        self
8742    }
8743
8744    /// Sets the value for use_global_endpoint
8745    ///
8746    /// When unset, this parameter has a default value of `false`.
8747    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
8748    pub fn set_use_global_endpoint(mut self, param: Option<bool>) -> Self {
8749        self.use_global_endpoint = param;
8750        self
8751    }
8752    /// Sets the value for use_object_lambda_endpoint
8753    ///
8754    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
8755    pub fn use_object_lambda_endpoint(mut self, value: impl Into<bool>) -> Self {
8756        self.use_object_lambda_endpoint = Some(value.into());
8757        self
8758    }
8759
8760    /// Sets the value for use_object_lambda_endpoint
8761    ///
8762    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
8763    pub fn set_use_object_lambda_endpoint(mut self, param: Option<bool>) -> Self {
8764        self.use_object_lambda_endpoint = param;
8765        self
8766    }
8767    /// Sets the value for key
8768    ///
8769    /// 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.
8770    pub fn key(mut self, value: impl Into<::std::string::String>) -> Self {
8771        self.key = Some(value.into());
8772        self
8773    }
8774
8775    /// Sets the value for key
8776    ///
8777    /// 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.
8778    pub fn set_key(mut self, param: Option<::std::string::String>) -> Self {
8779        self.key = param;
8780        self
8781    }
8782    /// Sets the value for prefix
8783    ///
8784    /// 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.
8785    pub fn prefix(mut self, value: impl Into<::std::string::String>) -> Self {
8786        self.prefix = Some(value.into());
8787        self
8788    }
8789
8790    /// Sets the value for prefix
8791    ///
8792    /// 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.
8793    pub fn set_prefix(mut self, param: Option<::std::string::String>) -> Self {
8794        self.prefix = param;
8795        self
8796    }
8797    /// Sets the value for disable_access_points
8798    ///
8799    /// Internal parameter to disable Access Point Buckets
8800    pub fn disable_access_points(mut self, value: impl Into<bool>) -> Self {
8801        self.disable_access_points = Some(value.into());
8802        self
8803    }
8804
8805    /// Sets the value for disable_access_points
8806    ///
8807    /// Internal parameter to disable Access Point Buckets
8808    pub fn set_disable_access_points(mut self, param: Option<bool>) -> Self {
8809        self.disable_access_points = param;
8810        self
8811    }
8812    /// Sets the value for disable_multi_region_access_points
8813    ///
8814    /// When unset, this parameter has a default value of `false`.
8815    /// Whether multi-region access points (MRAP) should be disabled.
8816    pub fn disable_multi_region_access_points(mut self, value: impl Into<bool>) -> Self {
8817        self.disable_multi_region_access_points = Some(value.into());
8818        self
8819    }
8820
8821    /// Sets the value for disable_multi_region_access_points
8822    ///
8823    /// When unset, this parameter has a default value of `false`.
8824    /// Whether multi-region access points (MRAP) should be disabled.
8825    pub fn set_disable_multi_region_access_points(mut self, param: Option<bool>) -> Self {
8826        self.disable_multi_region_access_points = param;
8827        self
8828    }
8829    /// Sets the value for use_arn_region
8830    ///
8831    /// 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.
8832    pub fn use_arn_region(mut self, value: impl Into<bool>) -> Self {
8833        self.use_arn_region = Some(value.into());
8834        self
8835    }
8836
8837    /// Sets the value for use_arn_region
8838    ///
8839    /// 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.
8840    pub fn set_use_arn_region(mut self, param: Option<bool>) -> Self {
8841        self.use_arn_region = param;
8842        self
8843    }
8844    /// Sets the value for use_s3_express_control_endpoint
8845    ///
8846    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
8847    pub fn use_s3_express_control_endpoint(mut self, value: impl Into<bool>) -> Self {
8848        self.use_s3_express_control_endpoint = Some(value.into());
8849        self
8850    }
8851
8852    /// Sets the value for use_s3_express_control_endpoint
8853    ///
8854    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
8855    pub fn set_use_s3_express_control_endpoint(mut self, param: Option<bool>) -> Self {
8856        self.use_s3_express_control_endpoint = param;
8857        self
8858    }
8859    /// Sets the value for disable_s3_express_session_auth
8860    ///
8861    /// Parameter to indicate whether S3Express session auth should be disabled
8862    pub fn disable_s3_express_session_auth(mut self, value: impl Into<bool>) -> Self {
8863        self.disable_s3_express_session_auth = Some(value.into());
8864        self
8865    }
8866
8867    /// Sets the value for disable_s3_express_session_auth
8868    ///
8869    /// Parameter to indicate whether S3Express session auth should be disabled
8870    pub fn set_disable_s3_express_session_auth(mut self, param: Option<bool>) -> Self {
8871        self.disable_s3_express_session_auth = param;
8872        self
8873    }
8874}
8875
8876/// An error that occurred during endpoint resolution
8877#[derive(Debug)]
8878pub struct InvalidParams {
8879    field: std::borrow::Cow<'static, str>,
8880}
8881
8882impl InvalidParams {
8883    #[allow(dead_code)]
8884    fn missing(field: &'static str) -> Self {
8885        Self { field: field.into() }
8886    }
8887}
8888
8889impl std::fmt::Display for InvalidParams {
8890    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8891        write!(f, "a required field was missing: `{}`", self.field)
8892    }
8893}
8894
8895impl std::error::Error for InvalidParams {}
8896
8897mod internals;
aws_sdk_s3/config/endpoint.rs

aws_sdk_s3/config/
endpoint.rs
