aws_sdk_s3/config/
endpoint.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2pub use ::aws_smithy_runtime_api::client::endpoint::EndpointFuture;
3pub use ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver;
4pub use ::aws_smithy_types::endpoint::Endpoint;
5
6#[cfg(test)]
7mod test {
8
9    /// region is not a valid DNS-suffix
10    #[test]
11    fn test_1() {
12        let params = crate::config::endpoint::Params::builder()
13            .region("a b".to_string())
14            .use_fips(false)
15            .use_dual_stack(false)
16            .accelerate(false)
17            .build()
18            .expect("invalid params");
19        let resolver = crate::config::endpoint::DefaultResolver::new();
20        let endpoint = resolver.resolve_endpoint(&params);
21        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [region is not a valid DNS-suffix]");
22        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
23    }
24
25    /// Invalid access point ARN: Not S3
26    #[test]
27    fn test_2() {
28        let params = crate::config::endpoint::Params::builder()
29            .region("us-east-1".to_string())
30            .use_fips(false)
31            .use_dual_stack(false)
32            .accelerate(false)
33            .bucket("arn:aws:not-s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
34            .build()
35            .expect("invalid params");
36        let resolver = crate::config::endpoint::DefaultResolver::new();
37        let endpoint = resolver.resolve_endpoint(&params);
38        let error =
39            endpoint.expect_err("expected error: Invalid ARN: The ARN was not for the S3 service, found: not-s3 [Invalid access point ARN: Not S3]");
40        assert_eq!(format!("{}", error), "Invalid ARN: The ARN was not for the S3 service, found: not-s3")
41    }
42
43    /// Invalid access point ARN: invalid resource
44    #[test]
45    fn test_3() {
46        let params = crate::config::endpoint::Params::builder()
47            .region("us-east-1".to_string())
48            .use_fips(false)
49            .use_dual_stack(false)
50            .accelerate(false)
51            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint:more-data".to_string())
52            .build()
53            .expect("invalid params");
54        let resolver = crate::config::endpoint::DefaultResolver::new();
55        let endpoint = resolver.resolve_endpoint(&params);
56        let error = endpoint.expect_err("expected error: Invalid ARN: The ARN may only contain a single resource component after `accesspoint`. [Invalid access point ARN: invalid resource]");
57        assert_eq!(
58            format!("{}", error),
59            "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`."
60        )
61    }
62
63    /// Invalid access point ARN: invalid no ap name
64    #[test]
65    fn test_4() {
66        let params = crate::config::endpoint::Params::builder()
67            .region("us-east-1".to_string())
68            .use_fips(false)
69            .use_dual_stack(false)
70            .accelerate(false)
71            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:".to_string())
72            .build()
73            .expect("invalid params");
74        let resolver = crate::config::endpoint::DefaultResolver::new();
75        let endpoint = resolver.resolve_endpoint(&params);
76        let error = endpoint.expect_err("expected error: Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided [Invalid access point ARN: invalid no ap name]");
77        assert_eq!(
78            format!("{}", error),
79            "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided"
80        )
81    }
82
83    /// Invalid access point ARN: AccountId is invalid
84    #[test]
85    fn test_5() {
86        let params = crate::config::endpoint::Params::builder()
87            .region("us-east-1".to_string())
88            .use_fips(false)
89            .use_dual_stack(false)
90            .accelerate(false)
91            .bucket("arn:aws:s3:us-west-2:123456_789012:accesspoint:apname".to_string())
92            .build()
93            .expect("invalid params");
94        let resolver = crate::config::endpoint::DefaultResolver::new();
95        let endpoint = resolver.resolve_endpoint(&params);
96        let error = endpoint.expect_err("expected error: Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123456_789012` [Invalid access point ARN: AccountId is invalid]");
97        assert_eq!(
98            format!("{}", error),
99            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123456_789012`"
100        )
101    }
102
103    /// Invalid access point ARN: access point name is invalid
104    #[test]
105    fn test_6() {
106        let params = crate::config::endpoint::Params::builder()
107            .region("us-east-1".to_string())
108            .use_fips(false)
109            .use_dual_stack(false)
110            .accelerate(false)
111            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:ap_name".to_string())
112            .build()
113            .expect("invalid params");
114        let resolver = crate::config::endpoint::DefaultResolver::new();
115        let endpoint = resolver.resolve_endpoint(&params);
116        let error = endpoint.expect_err("expected error: Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `ap_name` [Invalid access point ARN: access point name is invalid]");
117        assert_eq!(
118            format!("{}", error),
119            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `ap_name`"
120        )
121    }
122
123    /// Access points (disable access points explicitly false)
124    #[test]
125    fn test_7() {
126        let params = crate::config::endpoint::Params::builder()
127            .region("us-east-1".to_string())
128            .use_fips(false)
129            .use_dual_stack(false)
130            .accelerate(false)
131            .disable_access_points(false)
132            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
133            .build()
134            .expect("invalid params");
135        let resolver = crate::config::endpoint::DefaultResolver::new();
136        let endpoint = resolver.resolve_endpoint(&params);
137        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
138        assert_eq!(
139            endpoint,
140            ::aws_smithy_types::endpoint::Endpoint::builder()
141                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
142                .property(
143                    "authSchemes",
144                    vec![::aws_smithy_types::Document::from({
145                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
146                        out.insert("name".to_string(), "sigv4".to_string().into());
147                        out.insert("signingName".to_string(), "s3".to_string().into());
148                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
149                        out.insert("disableDoubleEncoding".to_string(), true.into());
150                        out
151                    })]
152                )
153                .build()
154        );
155    }
156
157    /// Access points: partition does not support FIPS
158    #[test]
159    fn test_8() {
160        let params = crate::config::endpoint::Params::builder()
161            .region("cn-north-1".to_string())
162            .use_fips(true)
163            .use_dual_stack(false)
164            .accelerate(false)
165            .bucket("arn:aws:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
166            .build()
167            .expect("invalid params");
168        let resolver = crate::config::endpoint::DefaultResolver::new();
169        let endpoint = resolver.resolve_endpoint(&params);
170        let error = endpoint.expect_err("expected error: Partition does not support FIPS [Access points: partition does not support FIPS]");
171        assert_eq!(format!("{}", error), "Partition does not support FIPS")
172    }
173
174    /// Bucket region is invalid
175    #[test]
176    fn test_9() {
177        let params = crate::config::endpoint::Params::builder()
178            .region("us-east-1".to_string())
179            .use_fips(false)
180            .use_dual_stack(false)
181            .accelerate(false)
182            .disable_access_points(false)
183            .bucket("arn:aws:s3:us-west -2:123456789012:accesspoint:myendpoint".to_string())
184            .build()
185            .expect("invalid params");
186        let resolver = crate::config::endpoint::DefaultResolver::new();
187        let endpoint = resolver.resolve_endpoint(&params);
188        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-west -2` (invalid DNS name) [Bucket region is invalid]");
189        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-west -2` (invalid DNS name)")
190    }
191
192    /// Access points when Access points explicitly disabled (used for CreateBucket)
193    #[test]
194    fn test_10() {
195        let params = crate::config::endpoint::Params::builder()
196            .region("us-east-1".to_string())
197            .use_fips(false)
198            .use_dual_stack(false)
199            .accelerate(false)
200            .disable_access_points(true)
201            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
202            .build()
203            .expect("invalid params");
204        let resolver = crate::config::endpoint::DefaultResolver::new();
205        let endpoint = resolver.resolve_endpoint(&params);
206        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)]");
207        assert_eq!(format!("{}", error), "Access points are not supported for this operation")
208    }
209
210    /// missing arn type
211    #[test]
212    fn test_11() {
213        let params = crate::config::endpoint::Params::builder()
214            .region("us-east-1".to_string())
215            .use_fips(false)
216            .use_dual_stack(false)
217            .accelerate(false)
218            .disable_access_points(true)
219            .bucket("arn:aws:s3:us-west-2:123456789012:".to_string())
220            .build()
221            .expect("invalid params");
222        let resolver = crate::config::endpoint::DefaultResolver::new();
223        let endpoint = resolver.resolve_endpoint(&params);
224        let error = endpoint.expect_err("expected error: Invalid ARN: `arn:aws:s3:us-west-2:123456789012:` was not a valid ARN [missing arn type]");
225        assert_eq!(
226            format!("{}", error),
227            "Invalid ARN: `arn:aws:s3:us-west-2:123456789012:` was not a valid ARN"
228        )
229    }
230
231    /// SDK::Host + access point + Dualstack is an error
232    #[test]
233    fn test_12() {
234        let params = crate::config::endpoint::Params::builder()
235            .accelerate(false)
236            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
237            .force_path_style(false)
238            .endpoint("https://beta.example.com".to_string())
239            .region("cn-north-1".to_string())
240            .use_dual_stack(true)
241            .use_fips(false)
242            .build()
243            .expect("invalid params");
244        let resolver = crate::config::endpoint::DefaultResolver::new();
245        let endpoint = resolver.resolve_endpoint(&params);
246        let error = endpoint.expect_err(
247            "expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + access point + Dualstack is an error]",
248        );
249        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
250    }
251
252    /// Access point ARN with FIPS & Dualstack
253    #[test]
254    fn test_13() {
255        let params = crate::config::endpoint::Params::builder()
256            .region("us-east-1".to_string())
257            .use_fips(true)
258            .use_dual_stack(true)
259            .accelerate(false)
260            .disable_access_points(false)
261            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
262            .build()
263            .expect("invalid params");
264        let resolver = crate::config::endpoint::DefaultResolver::new();
265        let endpoint = resolver.resolve_endpoint(&params);
266        let endpoint =
267            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com");
268        assert_eq!(
269            endpoint,
270            ::aws_smithy_types::endpoint::Endpoint::builder()
271                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com")
272                .property(
273                    "authSchemes",
274                    vec![::aws_smithy_types::Document::from({
275                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
276                        out.insert("name".to_string(), "sigv4".to_string().into());
277                        out.insert("signingName".to_string(), "s3".to_string().into());
278                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
279                        out.insert("disableDoubleEncoding".to_string(), true.into());
280                        out
281                    })]
282                )
283                .build()
284        );
285    }
286
287    /// Access point ARN with Dualstack
288    #[test]
289    fn test_14() {
290        let params = crate::config::endpoint::Params::builder()
291            .region("us-east-1".to_string())
292            .use_fips(false)
293            .use_dual_stack(true)
294            .accelerate(false)
295            .disable_access_points(false)
296            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
297            .build()
298            .expect("invalid params");
299        let resolver = crate::config::endpoint::DefaultResolver::new();
300        let endpoint = resolver.resolve_endpoint(&params);
301        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.dualstack.us-west-2.amazonaws.com");
302        assert_eq!(
303            endpoint,
304            ::aws_smithy_types::endpoint::Endpoint::builder()
305                .url("https://myendpoint-123456789012.s3-accesspoint.dualstack.us-west-2.amazonaws.com")
306                .property(
307                    "authSchemes",
308                    vec![::aws_smithy_types::Document::from({
309                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
310                        out.insert("name".to_string(), "sigv4".to_string().into());
311                        out.insert("signingName".to_string(), "s3".to_string().into());
312                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
313                        out.insert("disableDoubleEncoding".to_string(), true.into());
314                        out
315                    })]
316                )
317                .build()
318        );
319    }
320
321    /// vanilla MRAP
322    #[test]
323    fn test_15() {
324        let params = crate::config::endpoint::Params::builder()
325            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
326            .region("us-east-1".to_string())
327            .disable_multi_region_access_points(false)
328            .use_fips(false)
329            .use_dual_stack(false)
330            .accelerate(false)
331            .build()
332            .expect("invalid params");
333        let resolver = crate::config::endpoint::DefaultResolver::new();
334        let endpoint = resolver.resolve_endpoint(&params);
335        let endpoint = endpoint.expect("Expected valid endpoint: https://mfzwi23gnjvgw.mrap.accesspoint.s3-global.amazonaws.com");
336        assert_eq!(
337            endpoint,
338            ::aws_smithy_types::endpoint::Endpoint::builder()
339                .url("https://mfzwi23gnjvgw.mrap.accesspoint.s3-global.amazonaws.com")
340                .property(
341                    "authSchemes",
342                    vec![::aws_smithy_types::Document::from({
343                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
344                        out.insert("name".to_string(), "sigv4a".to_string().into());
345                        out.insert(
346                            "signingRegionSet".to_string(),
347                            vec![::aws_smithy_types::Document::from("*".to_string())].into(),
348                        );
349                        out.insert("signingName".to_string(), "s3".to_string().into());
350                        out.insert("disableDoubleEncoding".to_string(), true.into());
351                        out
352                    })]
353                )
354                .build()
355        );
356    }
357
358    /// MRAP does not support FIPS
359    #[test]
360    fn test_16() {
361        let params = crate::config::endpoint::Params::builder()
362            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
363            .region("us-east-1".to_string())
364            .disable_multi_region_access_points(false)
365            .use_fips(true)
366            .use_dual_stack(false)
367            .accelerate(false)
368            .build()
369            .expect("invalid params");
370        let resolver = crate::config::endpoint::DefaultResolver::new();
371        let endpoint = resolver.resolve_endpoint(&params);
372        let error = endpoint.expect_err("expected error: S3 MRAP does not support FIPS [MRAP does not support FIPS]");
373        assert_eq!(format!("{}", error), "S3 MRAP does not support FIPS")
374    }
375
376    /// MRAP does not support DualStack
377    #[test]
378    fn test_17() {
379        let params = crate::config::endpoint::Params::builder()
380            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
381            .region("us-east-1".to_string())
382            .disable_multi_region_access_points(false)
383            .use_fips(false)
384            .use_dual_stack(true)
385            .accelerate(false)
386            .build()
387            .expect("invalid params");
388        let resolver = crate::config::endpoint::DefaultResolver::new();
389        let endpoint = resolver.resolve_endpoint(&params);
390        let error = endpoint.expect_err("expected error: S3 MRAP does not support dual-stack [MRAP does not support DualStack]");
391        assert_eq!(format!("{}", error), "S3 MRAP does not support dual-stack")
392    }
393
394    /// MRAP does not support S3 Accelerate
395    #[test]
396    fn test_18() {
397        let params = crate::config::endpoint::Params::builder()
398            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
399            .region("us-east-1".to_string())
400            .disable_multi_region_access_points(false)
401            .use_fips(false)
402            .use_dual_stack(false)
403            .accelerate(true)
404            .build()
405            .expect("invalid params");
406        let resolver = crate::config::endpoint::DefaultResolver::new();
407        let endpoint = resolver.resolve_endpoint(&params);
408        let error = endpoint.expect_err("expected error: S3 MRAP does not support S3 Accelerate [MRAP does not support S3 Accelerate]");
409        assert_eq!(format!("{}", error), "S3 MRAP does not support S3 Accelerate")
410    }
411
412    /// MRAP explicitly disabled
413    #[test]
414    fn test_19() {
415        let params = crate::config::endpoint::Params::builder()
416            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
417            .region("us-east-1".to_string())
418            .disable_multi_region_access_points(true)
419            .use_fips(false)
420            .use_dual_stack(false)
421            .accelerate(false)
422            .build()
423            .expect("invalid params");
424        let resolver = crate::config::endpoint::DefaultResolver::new();
425        let endpoint = resolver.resolve_endpoint(&params);
426        let error =
427            endpoint.expect_err("expected error: Invalid configuration: Multi-Region Access Point ARNs are disabled. [MRAP explicitly disabled]");
428        assert_eq!(
429            format!("{}", error),
430            "Invalid configuration: Multi-Region Access Point ARNs are disabled."
431        )
432    }
433
434    /// Dual-stack endpoint with path-style forced
435    #[test]
436    fn test_20() {
437        let params = crate::config::endpoint::Params::builder()
438            .bucket("bucketname".to_string())
439            .region("us-west-2".to_string())
440            .force_path_style(true)
441            .use_fips(false)
442            .accelerate(false)
443            .use_dual_stack(true)
444            .build()
445            .expect("invalid params");
446        let resolver = crate::config::endpoint::DefaultResolver::new();
447        let endpoint = resolver.resolve_endpoint(&params);
448        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/bucketname");
449        assert_eq!(
450            endpoint,
451            ::aws_smithy_types::endpoint::Endpoint::builder()
452                .url("https://s3.dualstack.us-west-2.amazonaws.com/bucketname")
453                .property(
454                    "authSchemes",
455                    vec![::aws_smithy_types::Document::from({
456                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
457                        out.insert("name".to_string(), "sigv4".to_string().into());
458                        out.insert("signingName".to_string(), "s3".to_string().into());
459                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
460                        out.insert("disableDoubleEncoding".to_string(), true.into());
461                        out
462                    })]
463                )
464                .build()
465        );
466    }
467
468    /// Dual-stack endpoint + SDK::Host is error
469    #[test]
470    fn test_21() {
471        let params = crate::config::endpoint::Params::builder()
472            .bucket("bucketname".to_string())
473            .region("us-west-2".to_string())
474            .force_path_style(true)
475            .use_fips(false)
476            .accelerate(false)
477            .use_dual_stack(true)
478            .endpoint("https://abc.com".to_string())
479            .build()
480            .expect("invalid params");
481        let resolver = crate::config::endpoint::DefaultResolver::new();
482        let endpoint = resolver.resolve_endpoint(&params);
483        let error = endpoint
484            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [Dual-stack endpoint + SDK::Host is error]");
485        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
486    }
487
488    /// path style + ARN bucket
489    #[test]
490    fn test_22() {
491        let params = crate::config::endpoint::Params::builder()
492            .accelerate(false)
493            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
494            .force_path_style(true)
495            .region("us-west-2".to_string())
496            .use_dual_stack(false)
497            .use_fips(false)
498            .build()
499            .expect("invalid params");
500        let resolver = crate::config::endpoint::DefaultResolver::new();
501        let endpoint = resolver.resolve_endpoint(&params);
502        let error = endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + ARN bucket]");
503        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
504    }
505
506    /// implicit path style bucket + dualstack
507    #[test]
508    fn test_23() {
509        let params = crate::config::endpoint::Params::builder()
510            .accelerate(false)
511            .bucket("99_ab".to_string())
512            .region("us-west-2".to_string())
513            .use_dual_stack(true)
514            .use_fips(false)
515            .build()
516            .expect("invalid params");
517        let resolver = crate::config::endpoint::DefaultResolver::new();
518        let endpoint = resolver.resolve_endpoint(&params);
519        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/99_ab");
520        assert_eq!(
521            endpoint,
522            ::aws_smithy_types::endpoint::Endpoint::builder()
523                .url("https://s3.dualstack.us-west-2.amazonaws.com/99_ab")
524                .property(
525                    "authSchemes",
526                    vec![::aws_smithy_types::Document::from({
527                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
528                        out.insert("name".to_string(), "sigv4".to_string().into());
529                        out.insert("signingName".to_string(), "s3".to_string().into());
530                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
531                        out.insert("disableDoubleEncoding".to_string(), true.into());
532                        out
533                    })]
534                )
535                .build()
536        );
537    }
538
539    /// implicit path style bucket + dualstack
540    #[test]
541    fn test_24() {
542        let params = crate::config::endpoint::Params::builder()
543            .accelerate(false)
544            .bucket("99_ab".to_string())
545            .region("us-west-2".to_string())
546            .use_dual_stack(true)
547            .use_fips(false)
548            .endpoint("http://abc.com".to_string())
549            .build()
550            .expect("invalid params");
551        let resolver = crate::config::endpoint::DefaultResolver::new();
552        let endpoint = resolver.resolve_endpoint(&params);
553        let error = endpoint
554            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [implicit path style bucket + dualstack]");
555        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
556    }
557
558    /// don't allow URL injections in the bucket
559    #[test]
560    fn test_25() {
561        let params = crate::config::endpoint::Params::builder()
562            .bucket("example.com#".to_string())
563            .region("us-west-2".to_string())
564            .use_dual_stack(false)
565            .use_fips(false)
566            .accelerate(false)
567            .build()
568            .expect("invalid params");
569        let resolver = crate::config::endpoint::DefaultResolver::new();
570        let endpoint = resolver.resolve_endpoint(&params);
571        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/example.com%23");
572        assert_eq!(
573            endpoint,
574            ::aws_smithy_types::endpoint::Endpoint::builder()
575                .url("https://s3.us-west-2.amazonaws.com/example.com%23")
576                .property(
577                    "authSchemes",
578                    vec![::aws_smithy_types::Document::from({
579                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
580                        out.insert("name".to_string(), "sigv4".to_string().into());
581                        out.insert("signingName".to_string(), "s3".to_string().into());
582                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
583                        out.insert("disableDoubleEncoding".to_string(), true.into());
584                        out
585                    })]
586                )
587                .build()
588        );
589    }
590
591    /// URI encode bucket names in the path
592    #[test]
593    fn test_26() {
594        let params = crate::config::endpoint::Params::builder()
595            .bucket("bucket name".to_string())
596            .region("us-west-2".to_string())
597            .use_dual_stack(false)
598            .use_fips(false)
599            .accelerate(false)
600            .build()
601            .expect("invalid params");
602        let resolver = crate::config::endpoint::DefaultResolver::new();
603        let endpoint = resolver.resolve_endpoint(&params);
604        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket%20name");
605        assert_eq!(
606            endpoint,
607            ::aws_smithy_types::endpoint::Endpoint::builder()
608                .url("https://s3.us-west-2.amazonaws.com/bucket%20name")
609                .property(
610                    "authSchemes",
611                    vec![::aws_smithy_types::Document::from({
612                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
613                        out.insert("name".to_string(), "sigv4".to_string().into());
614                        out.insert("signingName".to_string(), "s3".to_string().into());
615                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
616                        out.insert("disableDoubleEncoding".to_string(), true.into());
617                        out
618                    })]
619                )
620                .build()
621        );
622    }
623
624    /// scheme is respected
625    #[test]
626    fn test_27() {
627        let params = crate::config::endpoint::Params::builder()
628            .accelerate(false)
629            .bucket("99_ab".to_string())
630            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
631            .region("af-south-1".to_string())
632            .use_dual_stack(false)
633            .use_fips(false)
634            .build()
635            .expect("invalid params");
636        let resolver = crate::config::endpoint::DefaultResolver::new();
637        let endpoint = resolver.resolve_endpoint(&params);
638        let endpoint = endpoint.expect("Expected valid endpoint: http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab");
639        assert_eq!(
640            endpoint,
641            ::aws_smithy_types::endpoint::Endpoint::builder()
642                .url("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab")
643                .property(
644                    "authSchemes",
645                    vec![::aws_smithy_types::Document::from({
646                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
647                        out.insert("name".to_string(), "sigv4".to_string().into());
648                        out.insert("signingName".to_string(), "s3".to_string().into());
649                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
650                        out.insert("disableDoubleEncoding".to_string(), true.into());
651                        out
652                    })]
653                )
654                .build()
655        );
656    }
657
658    /// scheme is respected (virtual addressing)
659    #[test]
660    fn test_28() {
661        let params = crate::config::endpoint::Params::builder()
662            .accelerate(false)
663            .bucket("bucketname".to_string())
664            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo".to_string())
665            .region("af-south-1".to_string())
666            .use_dual_stack(false)
667            .use_fips(false)
668            .build()
669            .expect("invalid params");
670        let resolver = crate::config::endpoint::DefaultResolver::new();
671        let endpoint = resolver.resolve_endpoint(&params);
672        let endpoint = endpoint.expect("Expected valid endpoint: http://bucketname.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo");
673        assert_eq!(
674            endpoint,
675            ::aws_smithy_types::endpoint::Endpoint::builder()
676                .url("http://bucketname.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo")
677                .property(
678                    "authSchemes",
679                    vec![::aws_smithy_types::Document::from({
680                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
681                        out.insert("name".to_string(), "sigv4".to_string().into());
682                        out.insert("signingName".to_string(), "s3".to_string().into());
683                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
684                        out.insert("disableDoubleEncoding".to_string(), true.into());
685                        out
686                    })]
687                )
688                .build()
689        );
690    }
691
692    /// path style + implicit private link
693    #[test]
694    fn test_29() {
695        let params = crate::config::endpoint::Params::builder()
696            .accelerate(false)
697            .bucket("99_ab".to_string())
698            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
699            .region("af-south-1".to_string())
700            .use_dual_stack(false)
701            .use_fips(false)
702            .build()
703            .expect("invalid params");
704        let resolver = crate::config::endpoint::DefaultResolver::new();
705        let endpoint = resolver.resolve_endpoint(&params);
706        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab");
707        assert_eq!(
708            endpoint,
709            ::aws_smithy_types::endpoint::Endpoint::builder()
710                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab")
711                .property(
712                    "authSchemes",
713                    vec![::aws_smithy_types::Document::from({
714                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
715                        out.insert("name".to_string(), "sigv4".to_string().into());
716                        out.insert("signingName".to_string(), "s3".to_string().into());
717                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
718                        out.insert("disableDoubleEncoding".to_string(), true.into());
719                        out
720                    })]
721                )
722                .build()
723        );
724    }
725
726    /// invalid Endpoint override
727    #[test]
728    fn test_30() {
729        let params = crate::config::endpoint::Params::builder()
730            .accelerate(false)
731            .bucket("bucketname".to_string())
732            .endpoint("abcde://nota#url".to_string())
733            .region("af-south-1".to_string())
734            .use_dual_stack(false)
735            .use_fips(false)
736            .build()
737            .expect("invalid params");
738        let resolver = crate::config::endpoint::DefaultResolver::new();
739        let endpoint = resolver.resolve_endpoint(&params);
740        let error = endpoint.expect_err("expected error: Custom endpoint `abcde://nota#url` was not a valid URI [invalid Endpoint override]");
741        assert_eq!(format!("{}", error), "Custom endpoint `abcde://nota#url` was not a valid URI")
742    }
743
744    /// using an IPv4 address forces path style
745    #[test]
746    fn test_31() {
747        let params = crate::config::endpoint::Params::builder()
748            .accelerate(false)
749            .bucket("bucketname".to_string())
750            .endpoint("https://123.123.0.1".to_string())
751            .region("af-south-1".to_string())
752            .use_dual_stack(false)
753            .use_fips(false)
754            .build()
755            .expect("invalid params");
756        let resolver = crate::config::endpoint::DefaultResolver::new();
757        let endpoint = resolver.resolve_endpoint(&params);
758        let endpoint = endpoint.expect("Expected valid endpoint: https://123.123.0.1/bucketname");
759        assert_eq!(
760            endpoint,
761            ::aws_smithy_types::endpoint::Endpoint::builder()
762                .url("https://123.123.0.1/bucketname")
763                .property(
764                    "authSchemes",
765                    vec![::aws_smithy_types::Document::from({
766                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
767                        out.insert("name".to_string(), "sigv4".to_string().into());
768                        out.insert("signingName".to_string(), "s3".to_string().into());
769                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
770                        out.insert("disableDoubleEncoding".to_string(), true.into());
771                        out
772                    })]
773                )
774                .build()
775        );
776    }
777
778    /// vanilla access point arn with region mismatch and UseArnRegion=false
779    #[test]
780    fn test_32() {
781        let params = crate::config::endpoint::Params::builder()
782            .accelerate(false)
783            .bucket("arn:aws:s3:us-east-1:123456789012:accesspoint:myendpoint".to_string())
784            .force_path_style(false)
785            .use_arn_region(false)
786            .region("us-west-2".to_string())
787            .use_dual_stack(false)
788            .use_fips(false)
789            .build()
790            .expect("invalid params");
791        let resolver = crate::config::endpoint::DefaultResolver::new();
792        let endpoint = resolver.resolve_endpoint(&params);
793        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]");
794        assert_eq!(
795            format!("{}", error),
796            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
797        )
798    }
799
800    /// vanilla access point arn with region mismatch and UseArnRegion unset
801    #[test]
802    fn test_33() {
803        let params = crate::config::endpoint::Params::builder()
804            .accelerate(false)
805            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
806            .force_path_style(false)
807            .region("us-east-1".to_string())
808            .use_dual_stack(false)
809            .use_fips(false)
810            .build()
811            .expect("invalid params");
812        let resolver = crate::config::endpoint::DefaultResolver::new();
813        let endpoint = resolver.resolve_endpoint(&params);
814        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
815        assert_eq!(
816            endpoint,
817            ::aws_smithy_types::endpoint::Endpoint::builder()
818                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
819                .property(
820                    "authSchemes",
821                    vec![::aws_smithy_types::Document::from({
822                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
823                        out.insert("name".to_string(), "sigv4".to_string().into());
824                        out.insert("signingName".to_string(), "s3".to_string().into());
825                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
826                        out.insert("disableDoubleEncoding".to_string(), true.into());
827                        out
828                    })]
829                )
830                .build()
831        );
832    }
833
834    /// vanilla access point arn with region mismatch and UseArnRegion=true
835    #[test]
836    fn test_34() {
837        let params = crate::config::endpoint::Params::builder()
838            .accelerate(false)
839            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
840            .force_path_style(false)
841            .use_arn_region(true)
842            .region("us-east-1".to_string())
843            .use_dual_stack(false)
844            .use_fips(false)
845            .build()
846            .expect("invalid params");
847        let resolver = crate::config::endpoint::DefaultResolver::new();
848        let endpoint = resolver.resolve_endpoint(&params);
849        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
850        assert_eq!(
851            endpoint,
852            ::aws_smithy_types::endpoint::Endpoint::builder()
853                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
854                .property(
855                    "authSchemes",
856                    vec![::aws_smithy_types::Document::from({
857                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
858                        out.insert("name".to_string(), "sigv4".to_string().into());
859                        out.insert("signingName".to_string(), "s3".to_string().into());
860                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
861                        out.insert("disableDoubleEncoding".to_string(), true.into());
862                        out
863                    })]
864                )
865                .build()
866        );
867    }
868
869    /// subdomains are not allowed in virtual buckets
870    #[test]
871    fn test_35() {
872        let params = crate::config::endpoint::Params::builder()
873            .bucket("bucket.name".to_string())
874            .region("us-east-1".to_string())
875            .build()
876            .expect("invalid params");
877        let resolver = crate::config::endpoint::DefaultResolver::new();
878        let endpoint = resolver.resolve_endpoint(&params);
879        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/bucket.name");
880        assert_eq!(
881            endpoint,
882            ::aws_smithy_types::endpoint::Endpoint::builder()
883                .url("https://s3.us-east-1.amazonaws.com/bucket.name")
884                .property(
885                    "authSchemes",
886                    vec![::aws_smithy_types::Document::from({
887                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
888                        out.insert("name".to_string(), "sigv4".to_string().into());
889                        out.insert("signingName".to_string(), "s3".to_string().into());
890                        out.insert("disableDoubleEncoding".to_string(), true.into());
891                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
892                        out
893                    })]
894                )
895                .build()
896        );
897    }
898
899    /// bucket names with 3 characters are allowed in virtual buckets
900    #[test]
901    fn test_36() {
902        let params = crate::config::endpoint::Params::builder()
903            .bucket("aaa".to_string())
904            .region("us-east-1".to_string())
905            .build()
906            .expect("invalid params");
907        let resolver = crate::config::endpoint::DefaultResolver::new();
908        let endpoint = resolver.resolve_endpoint(&params);
909        let endpoint = endpoint.expect("Expected valid endpoint: https://aaa.s3.us-east-1.amazonaws.com");
910        assert_eq!(
911            endpoint,
912            ::aws_smithy_types::endpoint::Endpoint::builder()
913                .url("https://aaa.s3.us-east-1.amazonaws.com")
914                .property(
915                    "authSchemes",
916                    vec![::aws_smithy_types::Document::from({
917                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
918                        out.insert("name".to_string(), "sigv4".to_string().into());
919                        out.insert("signingName".to_string(), "s3".to_string().into());
920                        out.insert("disableDoubleEncoding".to_string(), true.into());
921                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
922                        out
923                    })]
924                )
925                .build()
926        );
927    }
928
929    /// bucket names with fewer than 3 characters are not allowed in virtual host
930    #[test]
931    fn test_37() {
932        let params = crate::config::endpoint::Params::builder()
933            .bucket("aa".to_string())
934            .region("us-east-1".to_string())
935            .build()
936            .expect("invalid params");
937        let resolver = crate::config::endpoint::DefaultResolver::new();
938        let endpoint = resolver.resolve_endpoint(&params);
939        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/aa");
940        assert_eq!(
941            endpoint,
942            ::aws_smithy_types::endpoint::Endpoint::builder()
943                .url("https://s3.us-east-1.amazonaws.com/aa")
944                .property(
945                    "authSchemes",
946                    vec![::aws_smithy_types::Document::from({
947                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
948                        out.insert("name".to_string(), "sigv4".to_string().into());
949                        out.insert("signingName".to_string(), "s3".to_string().into());
950                        out.insert("disableDoubleEncoding".to_string(), true.into());
951                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
952                        out
953                    })]
954                )
955                .build()
956        );
957    }
958
959    /// bucket names with uppercase characters are not allowed in virtual host
960    #[test]
961    fn test_38() {
962        let params = crate::config::endpoint::Params::builder()
963            .bucket("BucketName".to_string())
964            .region("us-east-1".to_string())
965            .build()
966            .expect("invalid params");
967        let resolver = crate::config::endpoint::DefaultResolver::new();
968        let endpoint = resolver.resolve_endpoint(&params);
969        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/BucketName");
970        assert_eq!(
971            endpoint,
972            ::aws_smithy_types::endpoint::Endpoint::builder()
973                .url("https://s3.us-east-1.amazonaws.com/BucketName")
974                .property(
975                    "authSchemes",
976                    vec![::aws_smithy_types::Document::from({
977                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
978                        out.insert("name".to_string(), "sigv4".to_string().into());
979                        out.insert("signingName".to_string(), "s3".to_string().into());
980                        out.insert("disableDoubleEncoding".to_string(), true.into());
981                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
982                        out
983                    })]
984                )
985                .build()
986        );
987    }
988
989    /// subdomains are allowed in virtual buckets on http endpoints
990    #[test]
991    fn test_39() {
992        let params = crate::config::endpoint::Params::builder()
993            .bucket("bucket.name".to_string())
994            .region("us-east-1".to_string())
995            .endpoint("http://example.com".to_string())
996            .build()
997            .expect("invalid params");
998        let resolver = crate::config::endpoint::DefaultResolver::new();
999        let endpoint = resolver.resolve_endpoint(&params);
1000        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket.name.example.com");
1001        assert_eq!(
1002            endpoint,
1003            ::aws_smithy_types::endpoint::Endpoint::builder()
1004                .url("http://bucket.name.example.com")
1005                .property(
1006                    "authSchemes",
1007                    vec![::aws_smithy_types::Document::from({
1008                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1009                        out.insert("name".to_string(), "sigv4".to_string().into());
1010                        out.insert("signingName".to_string(), "s3".to_string().into());
1011                        out.insert("disableDoubleEncoding".to_string(), true.into());
1012                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1013                        out
1014                    })]
1015                )
1016                .build()
1017        );
1018    }
1019
1020    /// no region set
1021    #[test]
1022    fn test_40() {
1023        let params = crate::config::endpoint::Params::builder()
1024            .bucket("bucket-name".to_string())
1025            .build()
1026            .expect("invalid params");
1027        let resolver = crate::config::endpoint::DefaultResolver::new();
1028        let endpoint = resolver.resolve_endpoint(&params);
1029        let error = endpoint.expect_err("expected error: A region must be set when sending requests to S3. [no region set]");
1030        assert_eq!(format!("{}", error), "A region must be set when sending requests to S3.")
1031    }
1032
1033    /// UseGlobalEndpoints=true, region=us-east-1 uses the global endpoint
1034    #[test]
1035    fn test_41() {
1036        let params = crate::config::endpoint::Params::builder()
1037            .region("us-east-1".to_string())
1038            .use_global_endpoint(true)
1039            .use_fips(false)
1040            .use_dual_stack(false)
1041            .accelerate(false)
1042            .build()
1043            .expect("invalid params");
1044        let resolver = crate::config::endpoint::DefaultResolver::new();
1045        let endpoint = resolver.resolve_endpoint(&params);
1046        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1047        assert_eq!(
1048            endpoint,
1049            ::aws_smithy_types::endpoint::Endpoint::builder()
1050                .url("https://s3.amazonaws.com")
1051                .property(
1052                    "authSchemes",
1053                    vec![::aws_smithy_types::Document::from({
1054                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1055                        out.insert("name".to_string(), "sigv4".to_string().into());
1056                        out.insert("signingName".to_string(), "s3".to_string().into());
1057                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1058                        out.insert("disableDoubleEncoding".to_string(), true.into());
1059                        out
1060                    })]
1061                )
1062                .build()
1063        );
1064    }
1065
1066    /// UseGlobalEndpoints=true, region=us-west-2 uses the regional endpoint
1067    #[test]
1068    fn test_42() {
1069        let params = crate::config::endpoint::Params::builder()
1070            .region("us-west-2".to_string())
1071            .use_global_endpoint(true)
1072            .use_fips(false)
1073            .use_dual_stack(false)
1074            .accelerate(false)
1075            .build()
1076            .expect("invalid params");
1077        let resolver = crate::config::endpoint::DefaultResolver::new();
1078        let endpoint = resolver.resolve_endpoint(&params);
1079        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com");
1080        assert_eq!(
1081            endpoint,
1082            ::aws_smithy_types::endpoint::Endpoint::builder()
1083                .url("https://s3.us-west-2.amazonaws.com")
1084                .property(
1085                    "authSchemes",
1086                    vec![::aws_smithy_types::Document::from({
1087                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1088                        out.insert("name".to_string(), "sigv4".to_string().into());
1089                        out.insert("signingName".to_string(), "s3".to_string().into());
1090                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
1091                        out.insert("disableDoubleEncoding".to_string(), true.into());
1092                        out
1093                    })]
1094                )
1095                .build()
1096        );
1097    }
1098
1099    /// UseGlobalEndpoints=true, region=cn-north-1 uses the regional endpoint
1100    #[test]
1101    fn test_43() {
1102        let params = crate::config::endpoint::Params::builder()
1103            .region("cn-north-1".to_string())
1104            .use_global_endpoint(true)
1105            .use_fips(false)
1106            .use_dual_stack(false)
1107            .accelerate(false)
1108            .build()
1109            .expect("invalid params");
1110        let resolver = crate::config::endpoint::DefaultResolver::new();
1111        let endpoint = resolver.resolve_endpoint(&params);
1112        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn");
1113        assert_eq!(
1114            endpoint,
1115            ::aws_smithy_types::endpoint::Endpoint::builder()
1116                .url("https://s3.cn-north-1.amazonaws.com.cn")
1117                .property(
1118                    "authSchemes",
1119                    vec![::aws_smithy_types::Document::from({
1120                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1121                        out.insert("name".to_string(), "sigv4".to_string().into());
1122                        out.insert("signingName".to_string(), "s3".to_string().into());
1123                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
1124                        out.insert("disableDoubleEncoding".to_string(), true.into());
1125                        out
1126                    })]
1127                )
1128                .build()
1129        );
1130    }
1131
1132    /// UseGlobalEndpoints=true, region=us-east-1, fips=true uses the regional endpoint with fips
1133    #[test]
1134    fn test_44() {
1135        let params = crate::config::endpoint::Params::builder()
1136            .region("us-east-1".to_string())
1137            .use_global_endpoint(true)
1138            .use_fips(true)
1139            .use_dual_stack(false)
1140            .accelerate(false)
1141            .build()
1142            .expect("invalid params");
1143        let resolver = crate::config::endpoint::DefaultResolver::new();
1144        let endpoint = resolver.resolve_endpoint(&params);
1145        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com");
1146        assert_eq!(
1147            endpoint,
1148            ::aws_smithy_types::endpoint::Endpoint::builder()
1149                .url("https://s3-fips.us-east-1.amazonaws.com")
1150                .property(
1151                    "authSchemes",
1152                    vec![::aws_smithy_types::Document::from({
1153                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1154                        out.insert("name".to_string(), "sigv4".to_string().into());
1155                        out.insert("signingName".to_string(), "s3".to_string().into());
1156                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1157                        out.insert("disableDoubleEncoding".to_string(), true.into());
1158                        out
1159                    })]
1160                )
1161                .build()
1162        );
1163    }
1164
1165    /// UseGlobalEndpoints=true, region=us-east-1, dualstack=true uses the regional endpoint with dualstack
1166    #[test]
1167    fn test_45() {
1168        let params = crate::config::endpoint::Params::builder()
1169            .region("us-east-1".to_string())
1170            .use_global_endpoint(true)
1171            .use_fips(false)
1172            .use_dual_stack(true)
1173            .accelerate(false)
1174            .build()
1175            .expect("invalid params");
1176        let resolver = crate::config::endpoint::DefaultResolver::new();
1177        let endpoint = resolver.resolve_endpoint(&params);
1178        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com");
1179        assert_eq!(
1180            endpoint,
1181            ::aws_smithy_types::endpoint::Endpoint::builder()
1182                .url("https://s3.dualstack.us-east-1.amazonaws.com")
1183                .property(
1184                    "authSchemes",
1185                    vec![::aws_smithy_types::Document::from({
1186                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1187                        out.insert("name".to_string(), "sigv4".to_string().into());
1188                        out.insert("signingName".to_string(), "s3".to_string().into());
1189                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1190                        out.insert("disableDoubleEncoding".to_string(), true.into());
1191                        out
1192                    })]
1193                )
1194                .build()
1195        );
1196    }
1197
1198    /// UseGlobalEndpoints=true, region=us-east-1, dualstack and fips uses the regional endpoint with fips/dualstack
1199    #[test]
1200    fn test_46() {
1201        let params = crate::config::endpoint::Params::builder()
1202            .region("us-east-1".to_string())
1203            .use_global_endpoint(true)
1204            .use_fips(true)
1205            .use_dual_stack(true)
1206            .accelerate(false)
1207            .build()
1208            .expect("invalid params");
1209        let resolver = crate::config::endpoint::DefaultResolver::new();
1210        let endpoint = resolver.resolve_endpoint(&params);
1211        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com");
1212        assert_eq!(
1213            endpoint,
1214            ::aws_smithy_types::endpoint::Endpoint::builder()
1215                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com")
1216                .property(
1217                    "authSchemes",
1218                    vec![::aws_smithy_types::Document::from({
1219                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1220                        out.insert("name".to_string(), "sigv4".to_string().into());
1221                        out.insert("signingName".to_string(), "s3".to_string().into());
1222                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1223                        out.insert("disableDoubleEncoding".to_string(), true.into());
1224                        out
1225                    })]
1226                )
1227                .build()
1228        );
1229    }
1230
1231    /// UseGlobalEndpoints=true, region=us-east-1 with custom endpoint, uses custom
1232    #[test]
1233    fn test_47() {
1234        let params = crate::config::endpoint::Params::builder()
1235            .region("us-east-1".to_string())
1236            .endpoint("https://example.com".to_string())
1237            .use_global_endpoint(true)
1238            .use_fips(false)
1239            .use_dual_stack(false)
1240            .accelerate(false)
1241            .build()
1242            .expect("invalid params");
1243        let resolver = crate::config::endpoint::DefaultResolver::new();
1244        let endpoint = resolver.resolve_endpoint(&params);
1245        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1246        assert_eq!(
1247            endpoint,
1248            ::aws_smithy_types::endpoint::Endpoint::builder()
1249                .url("https://example.com")
1250                .property(
1251                    "authSchemes",
1252                    vec![::aws_smithy_types::Document::from({
1253                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1254                        out.insert("name".to_string(), "sigv4".to_string().into());
1255                        out.insert("signingName".to_string(), "s3".to_string().into());
1256                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1257                        out.insert("disableDoubleEncoding".to_string(), true.into());
1258                        out
1259                    })]
1260                )
1261                .build()
1262        );
1263    }
1264
1265    /// UseGlobalEndpoints=true, region=us-west-2 with custom endpoint, uses custom
1266    #[test]
1267    fn test_48() {
1268        let params = crate::config::endpoint::Params::builder()
1269            .region("us-west-2".to_string())
1270            .endpoint("https://example.com".to_string())
1271            .use_global_endpoint(true)
1272            .use_fips(false)
1273            .use_dual_stack(false)
1274            .accelerate(false)
1275            .build()
1276            .expect("invalid params");
1277        let resolver = crate::config::endpoint::DefaultResolver::new();
1278        let endpoint = resolver.resolve_endpoint(&params);
1279        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1280        assert_eq!(
1281            endpoint,
1282            ::aws_smithy_types::endpoint::Endpoint::builder()
1283                .url("https://example.com")
1284                .property(
1285                    "authSchemes",
1286                    vec![::aws_smithy_types::Document::from({
1287                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1288                        out.insert("name".to_string(), "sigv4".to_string().into());
1289                        out.insert("signingName".to_string(), "s3".to_string().into());
1290                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
1291                        out.insert("disableDoubleEncoding".to_string(), true.into());
1292                        out
1293                    })]
1294                )
1295                .build()
1296        );
1297    }
1298
1299    /// UseGlobalEndpoints=true, region=us-east-1 with accelerate on non bucket case uses the global endpoint and ignores accelerate
1300    #[test]
1301    fn test_49() {
1302        let params = crate::config::endpoint::Params::builder()
1303            .region("us-east-1".to_string())
1304            .use_global_endpoint(true)
1305            .use_fips(false)
1306            .use_dual_stack(false)
1307            .accelerate(true)
1308            .build()
1309            .expect("invalid params");
1310        let resolver = crate::config::endpoint::DefaultResolver::new();
1311        let endpoint = resolver.resolve_endpoint(&params);
1312        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1313        assert_eq!(
1314            endpoint,
1315            ::aws_smithy_types::endpoint::Endpoint::builder()
1316                .url("https://s3.amazonaws.com")
1317                .property(
1318                    "authSchemes",
1319                    vec![::aws_smithy_types::Document::from({
1320                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1321                        out.insert("name".to_string(), "sigv4".to_string().into());
1322                        out.insert("signingName".to_string(), "s3".to_string().into());
1323                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1324                        out.insert("disableDoubleEncoding".to_string(), true.into());
1325                        out
1326                    })]
1327                )
1328                .build()
1329        );
1330    }
1331
1332    /// aws-global region uses the global endpoint
1333    #[test]
1334    fn test_50() {
1335        let params = crate::config::endpoint::Params::builder()
1336            .region("aws-global".to_string())
1337            .use_fips(false)
1338            .use_dual_stack(false)
1339            .accelerate(false)
1340            .build()
1341            .expect("invalid params");
1342        let resolver = crate::config::endpoint::DefaultResolver::new();
1343        let endpoint = resolver.resolve_endpoint(&params);
1344        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1345        assert_eq!(
1346            endpoint,
1347            ::aws_smithy_types::endpoint::Endpoint::builder()
1348                .url("https://s3.amazonaws.com")
1349                .property(
1350                    "authSchemes",
1351                    vec![::aws_smithy_types::Document::from({
1352                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1353                        out.insert("name".to_string(), "sigv4".to_string().into());
1354                        out.insert("signingName".to_string(), "s3".to_string().into());
1355                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1356                        out.insert("disableDoubleEncoding".to_string(), true.into());
1357                        out
1358                    })]
1359                )
1360                .build()
1361        );
1362    }
1363
1364    /// aws-global region with fips uses the regional endpoint
1365    #[test]
1366    fn test_51() {
1367        let params = crate::config::endpoint::Params::builder()
1368            .region("aws-global".to_string())
1369            .use_fips(true)
1370            .use_dual_stack(false)
1371            .accelerate(false)
1372            .build()
1373            .expect("invalid params");
1374        let resolver = crate::config::endpoint::DefaultResolver::new();
1375        let endpoint = resolver.resolve_endpoint(&params);
1376        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com");
1377        assert_eq!(
1378            endpoint,
1379            ::aws_smithy_types::endpoint::Endpoint::builder()
1380                .url("https://s3-fips.us-east-1.amazonaws.com")
1381                .property(
1382                    "authSchemes",
1383                    vec![::aws_smithy_types::Document::from({
1384                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1385                        out.insert("name".to_string(), "sigv4".to_string().into());
1386                        out.insert("signingName".to_string(), "s3".to_string().into());
1387                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1388                        out.insert("disableDoubleEncoding".to_string(), true.into());
1389                        out
1390                    })]
1391                )
1392                .build()
1393        );
1394    }
1395
1396    /// aws-global region with dualstack uses the regional endpoint
1397    #[test]
1398    fn test_52() {
1399        let params = crate::config::endpoint::Params::builder()
1400            .region("aws-global".to_string())
1401            .use_fips(false)
1402            .use_dual_stack(true)
1403            .accelerate(false)
1404            .build()
1405            .expect("invalid params");
1406        let resolver = crate::config::endpoint::DefaultResolver::new();
1407        let endpoint = resolver.resolve_endpoint(&params);
1408        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com");
1409        assert_eq!(
1410            endpoint,
1411            ::aws_smithy_types::endpoint::Endpoint::builder()
1412                .url("https://s3.dualstack.us-east-1.amazonaws.com")
1413                .property(
1414                    "authSchemes",
1415                    vec![::aws_smithy_types::Document::from({
1416                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1417                        out.insert("name".to_string(), "sigv4".to_string().into());
1418                        out.insert("signingName".to_string(), "s3".to_string().into());
1419                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1420                        out.insert("disableDoubleEncoding".to_string(), true.into());
1421                        out
1422                    })]
1423                )
1424                .build()
1425        );
1426    }
1427
1428    /// aws-global region with fips and dualstack uses the regional endpoint
1429    #[test]
1430    fn test_53() {
1431        let params = crate::config::endpoint::Params::builder()
1432            .region("aws-global".to_string())
1433            .use_fips(true)
1434            .use_dual_stack(true)
1435            .accelerate(false)
1436            .build()
1437            .expect("invalid params");
1438        let resolver = crate::config::endpoint::DefaultResolver::new();
1439        let endpoint = resolver.resolve_endpoint(&params);
1440        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com");
1441        assert_eq!(
1442            endpoint,
1443            ::aws_smithy_types::endpoint::Endpoint::builder()
1444                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com")
1445                .property(
1446                    "authSchemes",
1447                    vec![::aws_smithy_types::Document::from({
1448                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1449                        out.insert("name".to_string(), "sigv4".to_string().into());
1450                        out.insert("signingName".to_string(), "s3".to_string().into());
1451                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1452                        out.insert("disableDoubleEncoding".to_string(), true.into());
1453                        out
1454                    })]
1455                )
1456                .build()
1457        );
1458    }
1459
1460    /// aws-global region with accelerate on non-bucket case, uses global endpoint and ignores accelerate
1461    #[test]
1462    fn test_54() {
1463        let params = crate::config::endpoint::Params::builder()
1464            .region("aws-global".to_string())
1465            .use_fips(false)
1466            .use_dual_stack(false)
1467            .accelerate(true)
1468            .build()
1469            .expect("invalid params");
1470        let resolver = crate::config::endpoint::DefaultResolver::new();
1471        let endpoint = resolver.resolve_endpoint(&params);
1472        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1473        assert_eq!(
1474            endpoint,
1475            ::aws_smithy_types::endpoint::Endpoint::builder()
1476                .url("https://s3.amazonaws.com")
1477                .property(
1478                    "authSchemes",
1479                    vec![::aws_smithy_types::Document::from({
1480                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1481                        out.insert("name".to_string(), "sigv4".to_string().into());
1482                        out.insert("signingName".to_string(), "s3".to_string().into());
1483                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1484                        out.insert("disableDoubleEncoding".to_string(), true.into());
1485                        out
1486                    })]
1487                )
1488                .build()
1489        );
1490    }
1491
1492    /// aws-global region with custom endpoint, uses custom
1493    #[test]
1494    fn test_55() {
1495        let params = crate::config::endpoint::Params::builder()
1496            .region("aws-global".to_string())
1497            .endpoint("https://example.com".to_string())
1498            .use_global_endpoint(false)
1499            .use_fips(false)
1500            .use_dual_stack(false)
1501            .accelerate(false)
1502            .build()
1503            .expect("invalid params");
1504        let resolver = crate::config::endpoint::DefaultResolver::new();
1505        let endpoint = resolver.resolve_endpoint(&params);
1506        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1507        assert_eq!(
1508            endpoint,
1509            ::aws_smithy_types::endpoint::Endpoint::builder()
1510                .url("https://example.com")
1511                .property(
1512                    "authSchemes",
1513                    vec![::aws_smithy_types::Document::from({
1514                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1515                        out.insert("name".to_string(), "sigv4".to_string().into());
1516                        out.insert("signingName".to_string(), "s3".to_string().into());
1517                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1518                        out.insert("disableDoubleEncoding".to_string(), true.into());
1519                        out
1520                    })]
1521                )
1522                .build()
1523        );
1524    }
1525
1526    /// virtual addressing, aws-global region uses the global endpoint
1527    #[test]
1528    fn test_56() {
1529        let params = crate::config::endpoint::Params::builder()
1530            .region("aws-global".to_string())
1531            .bucket("bucket-name".to_string())
1532            .use_fips(false)
1533            .use_dual_stack(false)
1534            .accelerate(false)
1535            .build()
1536            .expect("invalid params");
1537        let resolver = crate::config::endpoint::DefaultResolver::new();
1538        let endpoint = resolver.resolve_endpoint(&params);
1539        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1540        assert_eq!(
1541            endpoint,
1542            ::aws_smithy_types::endpoint::Endpoint::builder()
1543                .url("https://bucket-name.s3.amazonaws.com")
1544                .property(
1545                    "authSchemes",
1546                    vec![::aws_smithy_types::Document::from({
1547                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1548                        out.insert("name".to_string(), "sigv4".to_string().into());
1549                        out.insert("signingName".to_string(), "s3".to_string().into());
1550                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1551                        out.insert("disableDoubleEncoding".to_string(), true.into());
1552                        out
1553                    })]
1554                )
1555                .build()
1556        );
1557    }
1558
1559    /// virtual addressing, aws-global region with Prefix, and Key uses the global endpoint. Prefix and Key parameters should not be used in endpoint evaluation.
1560    #[test]
1561    fn test_57() {
1562        let params = crate::config::endpoint::Params::builder()
1563            .region("aws-global".to_string())
1564            .bucket("bucket-name".to_string())
1565            .use_fips(false)
1566            .use_dual_stack(false)
1567            .accelerate(false)
1568            .prefix("prefix".to_string())
1569            .key("key".to_string())
1570            .build()
1571            .expect("invalid params");
1572        let resolver = crate::config::endpoint::DefaultResolver::new();
1573        let endpoint = resolver.resolve_endpoint(&params);
1574        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1575        assert_eq!(
1576            endpoint,
1577            ::aws_smithy_types::endpoint::Endpoint::builder()
1578                .url("https://bucket-name.s3.amazonaws.com")
1579                .property(
1580                    "authSchemes",
1581                    vec![::aws_smithy_types::Document::from({
1582                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1583                        out.insert("name".to_string(), "sigv4".to_string().into());
1584                        out.insert("signingName".to_string(), "s3".to_string().into());
1585                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1586                        out.insert("disableDoubleEncoding".to_string(), true.into());
1587                        out
1588                    })]
1589                )
1590                .build()
1591        );
1592    }
1593
1594    /// virtual addressing, aws-global region with Copy Source, and Key uses the global endpoint. Copy Source and Key parameters should not be used in endpoint evaluation.
1595    #[test]
1596    fn test_58() {
1597        let params = crate::config::endpoint::Params::builder()
1598            .region("aws-global".to_string())
1599            .bucket("bucket-name".to_string())
1600            .use_fips(false)
1601            .use_dual_stack(false)
1602            .accelerate(false)
1603            .copy_source("/copy/source".to_string())
1604            .key("key".to_string())
1605            .build()
1606            .expect("invalid params");
1607        let resolver = crate::config::endpoint::DefaultResolver::new();
1608        let endpoint = resolver.resolve_endpoint(&params);
1609        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1610        assert_eq!(
1611            endpoint,
1612            ::aws_smithy_types::endpoint::Endpoint::builder()
1613                .url("https://bucket-name.s3.amazonaws.com")
1614                .property(
1615                    "authSchemes",
1616                    vec![::aws_smithy_types::Document::from({
1617                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1618                        out.insert("name".to_string(), "sigv4".to_string().into());
1619                        out.insert("signingName".to_string(), "s3".to_string().into());
1620                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1621                        out.insert("disableDoubleEncoding".to_string(), true.into());
1622                        out
1623                    })]
1624                )
1625                .build()
1626        );
1627    }
1628
1629    /// virtual addressing, aws-global region with fips uses the regional fips endpoint
1630    #[test]
1631    fn test_59() {
1632        let params = crate::config::endpoint::Params::builder()
1633            .region("aws-global".to_string())
1634            .bucket("bucket-name".to_string())
1635            .use_fips(true)
1636            .use_dual_stack(false)
1637            .accelerate(false)
1638            .build()
1639            .expect("invalid params");
1640        let resolver = crate::config::endpoint::DefaultResolver::new();
1641        let endpoint = resolver.resolve_endpoint(&params);
1642        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-east-1.amazonaws.com");
1643        assert_eq!(
1644            endpoint,
1645            ::aws_smithy_types::endpoint::Endpoint::builder()
1646                .url("https://bucket-name.s3-fips.us-east-1.amazonaws.com")
1647                .property(
1648                    "authSchemes",
1649                    vec![::aws_smithy_types::Document::from({
1650                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1651                        out.insert("name".to_string(), "sigv4".to_string().into());
1652                        out.insert("signingName".to_string(), "s3".to_string().into());
1653                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1654                        out.insert("disableDoubleEncoding".to_string(), true.into());
1655                        out
1656                    })]
1657                )
1658                .build()
1659        );
1660    }
1661
1662    /// virtual addressing, aws-global region with dualstack uses the regional dualstack endpoint
1663    #[test]
1664    fn test_60() {
1665        let params = crate::config::endpoint::Params::builder()
1666            .region("aws-global".to_string())
1667            .bucket("bucket-name".to_string())
1668            .use_fips(false)
1669            .use_dual_stack(true)
1670            .accelerate(false)
1671            .build()
1672            .expect("invalid params");
1673        let resolver = crate::config::endpoint::DefaultResolver::new();
1674        let endpoint = resolver.resolve_endpoint(&params);
1675        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-east-1.amazonaws.com");
1676        assert_eq!(
1677            endpoint,
1678            ::aws_smithy_types::endpoint::Endpoint::builder()
1679                .url("https://bucket-name.s3.dualstack.us-east-1.amazonaws.com")
1680                .property(
1681                    "authSchemes",
1682                    vec![::aws_smithy_types::Document::from({
1683                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1684                        out.insert("name".to_string(), "sigv4".to_string().into());
1685                        out.insert("signingName".to_string(), "s3".to_string().into());
1686                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1687                        out.insert("disableDoubleEncoding".to_string(), true.into());
1688                        out
1689                    })]
1690                )
1691                .build()
1692        );
1693    }
1694
1695    /// virtual addressing, aws-global region with fips/dualstack uses the regional fips/dualstack endpoint
1696    #[test]
1697    fn test_61() {
1698        let params = crate::config::endpoint::Params::builder()
1699            .region("aws-global".to_string())
1700            .bucket("bucket-name".to_string())
1701            .use_fips(true)
1702            .use_dual_stack(true)
1703            .accelerate(false)
1704            .build()
1705            .expect("invalid params");
1706        let resolver = crate::config::endpoint::DefaultResolver::new();
1707        let endpoint = resolver.resolve_endpoint(&params);
1708        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.us-east-1.amazonaws.com");
1709        assert_eq!(
1710            endpoint,
1711            ::aws_smithy_types::endpoint::Endpoint::builder()
1712                .url("https://bucket-name.s3-fips.dualstack.us-east-1.amazonaws.com")
1713                .property(
1714                    "authSchemes",
1715                    vec![::aws_smithy_types::Document::from({
1716                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1717                        out.insert("name".to_string(), "sigv4".to_string().into());
1718                        out.insert("signingName".to_string(), "s3".to_string().into());
1719                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1720                        out.insert("disableDoubleEncoding".to_string(), true.into());
1721                        out
1722                    })]
1723                )
1724                .build()
1725        );
1726    }
1727
1728    /// virtual addressing, aws-global region with accelerate uses the global accelerate endpoint
1729    #[test]
1730    fn test_62() {
1731        let params = crate::config::endpoint::Params::builder()
1732            .region("aws-global".to_string())
1733            .bucket("bucket-name".to_string())
1734            .use_fips(false)
1735            .use_dual_stack(false)
1736            .accelerate(true)
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.s3-accelerate.amazonaws.com");
1742        assert_eq!(
1743            endpoint,
1744            ::aws_smithy_types::endpoint::Endpoint::builder()
1745                .url("https://bucket-name.s3-accelerate.amazonaws.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, aws-global region with custom endpoint
1762    #[test]
1763    fn test_63() {
1764        let params = crate::config::endpoint::Params::builder()
1765            .region("aws-global".to_string())
1766            .endpoint("https://example.com".to_string())
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.example.com");
1776        assert_eq!(
1777            endpoint,
1778            ::aws_smithy_types::endpoint::Endpoint::builder()
1779                .url("https://bucket-name.example.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-east-1 region uses the global endpoint
1796    #[test]
1797    fn test_64() {
1798        let params = crate::config::endpoint::Params::builder()
1799            .region("us-east-1".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.amazonaws.com");
1810        assert_eq!(
1811            endpoint,
1812            ::aws_smithy_types::endpoint::Endpoint::builder()
1813                .url("https://bucket-name.s3.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-east-1".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-west-2 region uses the regional endpoint
1830    #[test]
1831    fn test_65() {
1832        let params = crate::config::endpoint::Params::builder()
1833            .region("us-west-2".to_string())
1834            .use_global_endpoint(true)
1835            .bucket("bucket-name".to_string())
1836            .use_fips(false)
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.us-west-2.amazonaws.com");
1844        assert_eq!(
1845            endpoint,
1846            ::aws_smithy_types::endpoint::Endpoint::builder()
1847                .url("https://bucket-name.s3.us-west-2.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-west-2".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 fips uses the regional fips 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(true)
1871            .use_dual_stack(false)
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-fips.us-east-1.amazonaws.com");
1878        assert_eq!(
1879            endpoint,
1880            ::aws_smithy_types::endpoint::Endpoint::builder()
1881                .url("https://bucket-name.s3-fips.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 dualstack uses the regional dualstack 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(true)
1906            .accelerate(false)
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.dualstack.us-east-1.amazonaws.com");
1912        assert_eq!(
1913            endpoint,
1914            ::aws_smithy_types::endpoint::Endpoint::builder()
1915                .url("https://bucket-name.s3.dualstack.us-east-1.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 and accelerate uses the global accelerate endpoint
1932    #[test]
1933    fn test_68() {
1934        let params = crate::config::endpoint::Params::builder()
1935            .region("us-east-1".to_string())
1936            .use_global_endpoint(true)
1937            .bucket("bucket-name".to_string())
1938            .use_fips(false)
1939            .use_dual_stack(false)
1940            .accelerate(true)
1941            .build()
1942            .expect("invalid params");
1943        let resolver = crate::config::endpoint::DefaultResolver::new();
1944        let endpoint = resolver.resolve_endpoint(&params);
1945        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
1946        assert_eq!(
1947            endpoint,
1948            ::aws_smithy_types::endpoint::Endpoint::builder()
1949                .url("https://bucket-name.s3-accelerate.amazonaws.com")
1950                .property(
1951                    "authSchemes",
1952                    vec![::aws_smithy_types::Document::from({
1953                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1954                        out.insert("name".to_string(), "sigv4".to_string().into());
1955                        out.insert("signingName".to_string(), "s3".to_string().into());
1956                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1957                        out.insert("disableDoubleEncoding".to_string(), true.into());
1958                        out
1959                    })]
1960                )
1961                .build()
1962        );
1963    }
1964
1965    /// virtual addressing, UseGlobalEndpoint and us-east-1 region with custom endpoint
1966    #[test]
1967    fn test_69() {
1968        let params = crate::config::endpoint::Params::builder()
1969            .region("us-east-1".to_string())
1970            .endpoint("https://example.com".to_string())
1971            .use_global_endpoint(true)
1972            .bucket("bucket-name".to_string())
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://bucket-name.example.com");
1981        assert_eq!(
1982            endpoint,
1983            ::aws_smithy_types::endpoint::Endpoint::builder()
1984                .url("https://bucket-name.example.com")
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 uses the global endpoint
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(false)
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.amazonaws.com/bucket-name");
2015        assert_eq!(
2016            endpoint,
2017            ::aws_smithy_types::endpoint::Endpoint::builder()
2018                .url("https://s3.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("name".to_string(), "sigv4".to_string().into());
2024                        out.insert("signingName".to_string(), "s3".to_string().into());
2025                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2026                        out.insert("disableDoubleEncoding".to_string(), true.into());
2027                        out
2028                    })]
2029                )
2030                .build()
2031        );
2032    }
2033
2034    /// ForcePathStyle, aws-global region with fips is invalid
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(true)
2042            .use_dual_stack(false)
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-fips.us-east-1.amazonaws.com/bucket-name");
2049        assert_eq!(
2050            endpoint,
2051            ::aws_smithy_types::endpoint::Endpoint::builder()
2052                .url("https://s3-fips.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("signingName".to_string(), "s3".to_string().into());
2058                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2059                        out.insert("disableDoubleEncoding".to_string(), true.into());
2060                        out.insert("name".to_string(), "sigv4".to_string().into());
2061                        out
2062                    })]
2063                )
2064                .build()
2065        );
2066    }
2067
2068    /// ForcePathStyle, aws-global region with dualstack uses regional dualstack endpoint
2069    #[test]
2070    fn test_72() {
2071        let params = crate::config::endpoint::Params::builder()
2072            .region("aws-global".to_string())
2073            .bucket("bucket-name".to_string())
2074            .force_path_style(true)
2075            .use_fips(false)
2076            .use_dual_stack(true)
2077            .accelerate(false)
2078            .build()
2079            .expect("invalid params");
2080        let resolver = crate::config::endpoint::DefaultResolver::new();
2081        let endpoint = resolver.resolve_endpoint(&params);
2082        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket-name");
2083        assert_eq!(
2084            endpoint,
2085            ::aws_smithy_types::endpoint::Endpoint::builder()
2086                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket-name")
2087                .property(
2088                    "authSchemes",
2089                    vec![::aws_smithy_types::Document::from({
2090                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2091                        out.insert("name".to_string(), "sigv4".to_string().into());
2092                        out.insert("signingName".to_string(), "s3".to_string().into());
2093                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2094                        out.insert("disableDoubleEncoding".to_string(), true.into());
2095                        out
2096                    })]
2097                )
2098                .build()
2099        );
2100    }
2101
2102    /// ForcePathStyle, aws-global region custom endpoint uses the custom endpoint
2103    #[test]
2104    fn test_73() {
2105        let params = crate::config::endpoint::Params::builder()
2106            .region("aws-global".to_string())
2107            .endpoint("https://example.com".to_string())
2108            .bucket("bucket-name".to_string())
2109            .force_path_style(true)
2110            .use_fips(false)
2111            .use_dual_stack(false)
2112            .accelerate(false)
2113            .build()
2114            .expect("invalid params");
2115        let resolver = crate::config::endpoint::DefaultResolver::new();
2116        let endpoint = resolver.resolve_endpoint(&params);
2117        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com/bucket-name");
2118        assert_eq!(
2119            endpoint,
2120            ::aws_smithy_types::endpoint::Endpoint::builder()
2121                .url("https://example.com/bucket-name")
2122                .property(
2123                    "authSchemes",
2124                    vec![::aws_smithy_types::Document::from({
2125                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2126                        out.insert("name".to_string(), "sigv4".to_string().into());
2127                        out.insert("signingName".to_string(), "s3".to_string().into());
2128                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2129                        out.insert("disableDoubleEncoding".to_string(), true.into());
2130                        out
2131                    })]
2132                )
2133                .build()
2134        );
2135    }
2136
2137    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region uses the global endpoint
2138    #[test]
2139    fn test_74() {
2140        let params = crate::config::endpoint::Params::builder()
2141            .region("us-east-1".to_string())
2142            .bucket("bucket-name".to_string())
2143            .use_global_endpoint(true)
2144            .force_path_style(true)
2145            .use_fips(false)
2146            .use_dual_stack(false)
2147            .accelerate(false)
2148            .build()
2149            .expect("invalid params");
2150        let resolver = crate::config::endpoint::DefaultResolver::new();
2151        let endpoint = resolver.resolve_endpoint(&params);
2152        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket-name");
2153        assert_eq!(
2154            endpoint,
2155            ::aws_smithy_types::endpoint::Endpoint::builder()
2156                .url("https://s3.amazonaws.com/bucket-name")
2157                .property(
2158                    "authSchemes",
2159                    vec![::aws_smithy_types::Document::from({
2160                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2161                        out.insert("name".to_string(), "sigv4".to_string().into());
2162                        out.insert("signingName".to_string(), "s3".to_string().into());
2163                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2164                        out.insert("disableDoubleEncoding".to_string(), true.into());
2165                        out
2166                    })]
2167                )
2168                .build()
2169        );
2170    }
2171
2172    /// ForcePathStyle, UseGlobalEndpoint us-west-2 region uses the regional endpoint
2173    #[test]
2174    fn test_75() {
2175        let params = crate::config::endpoint::Params::builder()
2176            .region("us-west-2".to_string())
2177            .bucket("bucket-name".to_string())
2178            .use_global_endpoint(true)
2179            .force_path_style(true)
2180            .use_fips(false)
2181            .use_dual_stack(false)
2182            .accelerate(false)
2183            .build()
2184            .expect("invalid params");
2185        let resolver = crate::config::endpoint::DefaultResolver::new();
2186        let endpoint = resolver.resolve_endpoint(&params);
2187        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket-name");
2188        assert_eq!(
2189            endpoint,
2190            ::aws_smithy_types::endpoint::Endpoint::builder()
2191                .url("https://s3.us-west-2.amazonaws.com/bucket-name")
2192                .property(
2193                    "authSchemes",
2194                    vec![::aws_smithy_types::Document::from({
2195                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2196                        out.insert("name".to_string(), "sigv4".to_string().into());
2197                        out.insert("signingName".to_string(), "s3".to_string().into());
2198                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2199                        out.insert("disableDoubleEncoding".to_string(), true.into());
2200                        out
2201                    })]
2202                )
2203                .build()
2204        );
2205    }
2206
2207    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region, dualstack uses the regional dualstack endpoint
2208    #[test]
2209    fn test_76() {
2210        let params = crate::config::endpoint::Params::builder()
2211            .region("us-east-1".to_string())
2212            .bucket("bucket-name".to_string())
2213            .use_global_endpoint(true)
2214            .force_path_style(true)
2215            .use_fips(false)
2216            .use_dual_stack(true)
2217            .accelerate(false)
2218            .build()
2219            .expect("invalid params");
2220        let resolver = crate::config::endpoint::DefaultResolver::new();
2221        let endpoint = resolver.resolve_endpoint(&params);
2222        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket-name");
2223        assert_eq!(
2224            endpoint,
2225            ::aws_smithy_types::endpoint::Endpoint::builder()
2226                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket-name")
2227                .property(
2228                    "authSchemes",
2229                    vec![::aws_smithy_types::Document::from({
2230                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2231                        out.insert("name".to_string(), "sigv4".to_string().into());
2232                        out.insert("signingName".to_string(), "s3".to_string().into());
2233                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2234                        out.insert("disableDoubleEncoding".to_string(), true.into());
2235                        out
2236                    })]
2237                )
2238                .build()
2239        );
2240    }
2241
2242    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region custom endpoint uses the custom endpoint
2243    #[test]
2244    fn test_77() {
2245        let params = crate::config::endpoint::Params::builder()
2246            .region("us-east-1".to_string())
2247            .bucket("bucket-name".to_string())
2248            .endpoint("https://example.com".to_string())
2249            .use_global_endpoint(true)
2250            .force_path_style(true)
2251            .use_fips(false)
2252            .use_dual_stack(false)
2253            .accelerate(false)
2254            .build()
2255            .expect("invalid params");
2256        let resolver = crate::config::endpoint::DefaultResolver::new();
2257        let endpoint = resolver.resolve_endpoint(&params);
2258        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com/bucket-name");
2259        assert_eq!(
2260            endpoint,
2261            ::aws_smithy_types::endpoint::Endpoint::builder()
2262                .url("https://example.com/bucket-name")
2263                .property(
2264                    "authSchemes",
2265                    vec![::aws_smithy_types::Document::from({
2266                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2267                        out.insert("name".to_string(), "sigv4".to_string().into());
2268                        out.insert("signingName".to_string(), "s3".to_string().into());
2269                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2270                        out.insert("disableDoubleEncoding".to_string(), true.into());
2271                        out
2272                    })]
2273                )
2274                .build()
2275        );
2276    }
2277
2278    /// ARN with aws-global region and  UseArnRegion uses the regional endpoint
2279    #[test]
2280    fn test_78() {
2281        let params = crate::config::endpoint::Params::builder()
2282            .region("aws-global".to_string())
2283            .use_arn_region(true)
2284            .use_fips(false)
2285            .use_dual_stack(false)
2286            .accelerate(false)
2287            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
2288            .build()
2289            .expect("invalid params");
2290        let resolver = crate::config::endpoint::DefaultResolver::new();
2291        let endpoint = resolver.resolve_endpoint(&params);
2292        let endpoint =
2293            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
2294        assert_eq!(
2295            endpoint,
2296            ::aws_smithy_types::endpoint::Endpoint::builder()
2297                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
2298                .property(
2299                    "authSchemes",
2300                    vec![
2301                        ::aws_smithy_types::Document::from({
2302                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2303                            out.insert("name".to_string(), "sigv4a".to_string().into());
2304                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
2305                            out.insert(
2306                                "signingRegionSet".to_string(),
2307                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
2308                            );
2309                            out.insert("disableDoubleEncoding".to_string(), true.into());
2310                            out
2311                        }),
2312                        ::aws_smithy_types::Document::from({
2313                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2314                            out.insert("name".to_string(), "sigv4".to_string().into());
2315                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
2316                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2317                            out.insert("disableDoubleEncoding".to_string(), true.into());
2318                            out
2319                        })
2320                    ]
2321                )
2322                .build()
2323        );
2324    }
2325
2326    /// cross partition MRAP ARN is an error
2327    #[test]
2328    fn test_79() {
2329        let params = crate::config::endpoint::Params::builder()
2330            .bucket("arn:aws-cn:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
2331            .region("us-west-1".to_string())
2332            .build()
2333            .expect("invalid params");
2334        let resolver = crate::config::endpoint::DefaultResolver::new();
2335        let endpoint = resolver.resolve_endpoint(&params);
2336        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]");
2337        assert_eq!(
2338            format!("{}", error),
2339            "Client was configured for partition `aws` but bucket referred to partition `aws-cn`"
2340        )
2341    }
2342
2343    /// Endpoint override, accesspoint with HTTP, port
2344    #[test]
2345    fn test_80() {
2346        let params = crate::config::endpoint::Params::builder()
2347            .endpoint("http://beta.example.com:1234".to_string())
2348            .region("us-west-2".to_string())
2349            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
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");
2355        assert_eq!(
2356            endpoint,
2357            ::aws_smithy_types::endpoint::Endpoint::builder()
2358                .url("http://myendpoint-123456789012.beta.example.com:1234")
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    /// Endpoint override, accesspoint with http, path, query, and port
2375    #[test]
2376    fn test_81() {
2377        let params = crate::config::endpoint::Params::builder()
2378            .region("us-west-2".to_string())
2379            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
2380            .endpoint("http://beta.example.com:1234/path".to_string())
2381            .use_fips(false)
2382            .use_dual_stack(false)
2383            .accelerate(false)
2384            .build()
2385            .expect("invalid params");
2386        let resolver = crate::config::endpoint::DefaultResolver::new();
2387        let endpoint = resolver.resolve_endpoint(&params);
2388        let endpoint = endpoint.expect("Expected valid endpoint: http://myendpoint-123456789012.beta.example.com:1234/path");
2389        assert_eq!(
2390            endpoint,
2391            ::aws_smithy_types::endpoint::Endpoint::builder()
2392                .url("http://myendpoint-123456789012.beta.example.com:1234/path")
2393                .property(
2394                    "authSchemes",
2395                    vec![::aws_smithy_types::Document::from({
2396                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2397                        out.insert("name".to_string(), "sigv4".to_string().into());
2398                        out.insert("signingName".to_string(), "s3".to_string().into());
2399                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2400                        out.insert("disableDoubleEncoding".to_string(), true.into());
2401                        out
2402                    })]
2403                )
2404                .build()
2405        );
2406    }
2407
2408    /// non-bucket endpoint override with FIPS = error
2409    #[test]
2410    fn test_82() {
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(true)
2415            .use_dual_stack(false)
2416            .build()
2417            .expect("invalid params");
2418        let resolver = crate::config::endpoint::DefaultResolver::new();
2419        let endpoint = resolver.resolve_endpoint(&params);
2420        let error =
2421            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [non-bucket endpoint override with FIPS = error]");
2422        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2423    }
2424
2425    /// FIPS + dualstack + custom endpoint
2426    #[test]
2427    fn test_83() {
2428        let params = crate::config::endpoint::Params::builder()
2429            .region("us-west-2".to_string())
2430            .endpoint("http://beta.example.com:1234/path".to_string())
2431            .use_fips(true)
2432            .use_dual_stack(true)
2433            .build()
2434            .expect("invalid params");
2435        let resolver = crate::config::endpoint::DefaultResolver::new();
2436        let endpoint = resolver.resolve_endpoint(&params);
2437        let error =
2438            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [FIPS + dualstack + custom endpoint]");
2439        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
2440    }
2441
2442    /// dualstack + custom endpoint
2443    #[test]
2444    fn test_84() {
2445        let params = crate::config::endpoint::Params::builder()
2446            .region("us-west-2".to_string())
2447            .endpoint("http://beta.example.com:1234/path".to_string())
2448            .use_fips(false)
2449            .use_dual_stack(true)
2450            .build()
2451            .expect("invalid params");
2452        let resolver = crate::config::endpoint::DefaultResolver::new();
2453        let endpoint = resolver.resolve_endpoint(&params);
2454        let error = endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [dualstack + custom endpoint]");
2455        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
2456    }
2457
2458    /// custom endpoint without FIPS/dualstack
2459    #[test]
2460    fn test_85() {
2461        let params = crate::config::endpoint::Params::builder()
2462            .region("us-west-2".to_string())
2463            .endpoint("http://beta.example.com:1234/path".to_string())
2464            .use_fips(false)
2465            .use_dual_stack(false)
2466            .build()
2467            .expect("invalid params");
2468        let resolver = crate::config::endpoint::DefaultResolver::new();
2469        let endpoint = resolver.resolve_endpoint(&params);
2470        let endpoint = endpoint.expect("Expected valid endpoint: http://beta.example.com:1234/path");
2471        assert_eq!(
2472            endpoint,
2473            ::aws_smithy_types::endpoint::Endpoint::builder()
2474                .url("http://beta.example.com:1234/path")
2475                .property(
2476                    "authSchemes",
2477                    vec![::aws_smithy_types::Document::from({
2478                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2479                        out.insert("name".to_string(), "sigv4".to_string().into());
2480                        out.insert("signingName".to_string(), "s3".to_string().into());
2481                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2482                        out.insert("disableDoubleEncoding".to_string(), true.into());
2483                        out
2484                    })]
2485                )
2486                .build()
2487        );
2488    }
2489
2490    /// s3 object lambda with access points disabled
2491    #[test]
2492    fn test_86() {
2493        let params = crate::config::endpoint::Params::builder()
2494            .region("us-west-2".to_string())
2495            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:myendpoint".to_string())
2496            .disable_access_points(true)
2497            .build()
2498            .expect("invalid params");
2499        let resolver = crate::config::endpoint::DefaultResolver::new();
2500        let endpoint = resolver.resolve_endpoint(&params);
2501        let error =
2502            endpoint.expect_err("expected error: Access points are not supported for this operation [s3 object lambda with access points disabled]");
2503        assert_eq!(format!("{}", error), "Access points are not supported for this operation")
2504    }
2505
2506    /// non bucket + FIPS
2507    #[test]
2508    fn test_87() {
2509        let params = crate::config::endpoint::Params::builder()
2510            .region("us-west-2".to_string())
2511            .use_fips(true)
2512            .use_dual_stack(false)
2513            .build()
2514            .expect("invalid params");
2515        let resolver = crate::config::endpoint::DefaultResolver::new();
2516        let endpoint = resolver.resolve_endpoint(&params);
2517        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-west-2.amazonaws.com");
2518        assert_eq!(
2519            endpoint,
2520            ::aws_smithy_types::endpoint::Endpoint::builder()
2521                .url("https://s3-fips.us-west-2.amazonaws.com")
2522                .property(
2523                    "authSchemes",
2524                    vec![::aws_smithy_types::Document::from({
2525                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2526                        out.insert("name".to_string(), "sigv4".to_string().into());
2527                        out.insert("signingName".to_string(), "s3".to_string().into());
2528                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2529                        out.insert("disableDoubleEncoding".to_string(), true.into());
2530                        out
2531                    })]
2532                )
2533                .build()
2534        );
2535    }
2536
2537    /// standard non bucket endpoint
2538    #[test]
2539    fn test_88() {
2540        let params = crate::config::endpoint::Params::builder()
2541            .region("us-west-2".to_string())
2542            .use_fips(false)
2543            .use_dual_stack(false)
2544            .build()
2545            .expect("invalid params");
2546        let resolver = crate::config::endpoint::DefaultResolver::new();
2547        let endpoint = resolver.resolve_endpoint(&params);
2548        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com");
2549        assert_eq!(
2550            endpoint,
2551            ::aws_smithy_types::endpoint::Endpoint::builder()
2552                .url("https://s3.us-west-2.amazonaws.com")
2553                .property(
2554                    "authSchemes",
2555                    vec![::aws_smithy_types::Document::from({
2556                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2557                        out.insert("name".to_string(), "sigv4".to_string().into());
2558                        out.insert("signingName".to_string(), "s3".to_string().into());
2559                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2560                        out.insert("disableDoubleEncoding".to_string(), true.into());
2561                        out
2562                    })]
2563                )
2564                .build()
2565        );
2566    }
2567
2568    /// non bucket endpoint with FIPS + Dualstack
2569    #[test]
2570    fn test_89() {
2571        let params = crate::config::endpoint::Params::builder()
2572            .region("us-west-2".to_string())
2573            .use_fips(true)
2574            .use_dual_stack(true)
2575            .build()
2576            .expect("invalid params");
2577        let resolver = crate::config::endpoint::DefaultResolver::new();
2578        let endpoint = resolver.resolve_endpoint(&params);
2579        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-west-2.amazonaws.com");
2580        assert_eq!(
2581            endpoint,
2582            ::aws_smithy_types::endpoint::Endpoint::builder()
2583                .url("https://s3-fips.dualstack.us-west-2.amazonaws.com")
2584                .property(
2585                    "authSchemes",
2586                    vec![::aws_smithy_types::Document::from({
2587                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2588                        out.insert("name".to_string(), "sigv4".to_string().into());
2589                        out.insert("signingName".to_string(), "s3".to_string().into());
2590                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
2591                        out.insert("disableDoubleEncoding".to_string(), true.into());
2592                        out
2593                    })]
2594                )
2595                .build()
2596        );
2597    }
2598
2599    /// non bucket endpoint with dualstack
2600    #[test]
2601    fn test_90() {
2602        let params = crate::config::endpoint::Params::builder()
2603            .region("us-west-2".to_string())
2604            .use_fips(false)
2605            .use_dual_stack(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: https://s3.dualstack.us-west-2.amazonaws.com");
2611        assert_eq!(
2612            endpoint,
2613            ::aws_smithy_types::endpoint::Endpoint::builder()
2614                .url("https://s3.dualstack.us-west-2.amazonaws.com")
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("signingRegion".to_string(), "us-west-2".to_string().into());
2622                        out.insert("disableDoubleEncoding".to_string(), true.into());
2623                        out
2624                    })]
2625                )
2626                .build()
2627        );
2628    }
2629
2630    /// use global endpoint + IP address endpoint override
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            .endpoint("http://127.0.0.1".to_string())
2639            .use_global_endpoint(true)
2640            .build()
2641            .expect("invalid params");
2642        let resolver = crate::config::endpoint::DefaultResolver::new();
2643        let endpoint = resolver.resolve_endpoint(&params);
2644        let endpoint = endpoint.expect("Expected valid endpoint: http://127.0.0.1/bucket");
2645        assert_eq!(
2646            endpoint,
2647            ::aws_smithy_types::endpoint::Endpoint::builder()
2648                .url("http://127.0.0.1/bucket")
2649                .property(
2650                    "authSchemes",
2651                    vec![::aws_smithy_types::Document::from({
2652                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2653                        out.insert("name".to_string(), "sigv4".to_string().into());
2654                        out.insert("signingName".to_string(), "s3".to_string().into());
2655                        out.insert("disableDoubleEncoding".to_string(), true.into());
2656                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2657                        out
2658                    })]
2659                )
2660                .build()
2661        );
2662    }
2663
2664    /// non-dns endpoint + global endpoint
2665    #[test]
2666    fn test_92() {
2667        let params = crate::config::endpoint::Params::builder()
2668            .region("us-east-1".to_string())
2669            .bucket("bucket!".to_string())
2670            .use_fips(false)
2671            .use_dual_stack(false)
2672            .use_global_endpoint(true)
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: https://s3.amazonaws.com/bucket%21");
2678        assert_eq!(
2679            endpoint,
2680            ::aws_smithy_types::endpoint::Endpoint::builder()
2681                .url("https://s3.amazonaws.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    /// endpoint override + use global 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(false)
2704            .use_dual_stack(false)
2705            .use_global_endpoint(true)
2706            .endpoint("http://foo.com".to_string())
2707            .build()
2708            .expect("invalid params");
2709        let resolver = crate::config::endpoint::DefaultResolver::new();
2710        let endpoint = resolver.resolve_endpoint(&params);
2711        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
2712        assert_eq!(
2713            endpoint,
2714            ::aws_smithy_types::endpoint::Endpoint::builder()
2715                .url("http://foo.com/bucket%21")
2716                .property(
2717                    "authSchemes",
2718                    vec![::aws_smithy_types::Document::from({
2719                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2720                        out.insert("name".to_string(), "sigv4".to_string().into());
2721                        out.insert("signingName".to_string(), "s3".to_string().into());
2722                        out.insert("disableDoubleEncoding".to_string(), true.into());
2723                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2724                        out
2725                    })]
2726                )
2727                .build()
2728        );
2729    }
2730
2731    /// FIPS + dualstack + non-bucket endpoint
2732    #[test]
2733    fn test_94() {
2734        let params = crate::config::endpoint::Params::builder()
2735            .region("us-east-1".to_string())
2736            .bucket("bucket!".to_string())
2737            .use_fips(true)
2738            .use_dual_stack(true)
2739            .build()
2740            .expect("invalid params");
2741        let resolver = crate::config::endpoint::DefaultResolver::new();
2742        let endpoint = resolver.resolve_endpoint(&params);
2743        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
2744        assert_eq!(
2745            endpoint,
2746            ::aws_smithy_types::endpoint::Endpoint::builder()
2747                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
2748                .property(
2749                    "authSchemes",
2750                    vec![::aws_smithy_types::Document::from({
2751                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2752                        out.insert("name".to_string(), "sigv4".to_string().into());
2753                        out.insert("signingName".to_string(), "s3".to_string().into());
2754                        out.insert("disableDoubleEncoding".to_string(), true.into());
2755                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2756                        out
2757                    })]
2758                )
2759                .build()
2760        );
2761    }
2762
2763    /// FIPS + dualstack + non-DNS endpoint
2764    #[test]
2765    fn test_95() {
2766        let params = crate::config::endpoint::Params::builder()
2767            .region("us-east-1".to_string())
2768            .bucket("bucket!".to_string())
2769            .force_path_style(true)
2770            .use_fips(true)
2771            .use_dual_stack(true)
2772            .build()
2773            .expect("invalid params");
2774        let resolver = crate::config::endpoint::DefaultResolver::new();
2775        let endpoint = resolver.resolve_endpoint(&params);
2776        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
2777        assert_eq!(
2778            endpoint,
2779            ::aws_smithy_types::endpoint::Endpoint::builder()
2780                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
2781                .property(
2782                    "authSchemes",
2783                    vec![::aws_smithy_types::Document::from({
2784                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2785                        out.insert("name".to_string(), "sigv4".to_string().into());
2786                        out.insert("signingName".to_string(), "s3".to_string().into());
2787                        out.insert("disableDoubleEncoding".to_string(), true.into());
2788                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2789                        out
2790                    })]
2791                )
2792                .build()
2793        );
2794    }
2795
2796    /// endpoint override + FIPS + dualstack (BUG)
2797    #[test]
2798    fn test_96() {
2799        let params = crate::config::endpoint::Params::builder()
2800            .region("us-east-1".to_string())
2801            .bucket("bucket!".to_string())
2802            .force_path_style(true)
2803            .use_fips(true)
2804            .use_dual_stack(false)
2805            .endpoint("http://foo.com".to_string())
2806            .build()
2807            .expect("invalid params");
2808        let resolver = crate::config::endpoint::DefaultResolver::new();
2809        let endpoint = resolver.resolve_endpoint(&params);
2810        let error =
2811            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [endpoint override + FIPS + dualstack (BUG)]");
2812        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2813    }
2814
2815    /// endpoint override + non-dns bucket + FIPS (BUG)
2816    #[test]
2817    fn test_97() {
2818        let params = crate::config::endpoint::Params::builder()
2819            .region("us-east-1".to_string())
2820            .bucket("bucket!".to_string())
2821            .use_fips(true)
2822            .use_dual_stack(false)
2823            .endpoint("http://foo.com".to_string())
2824            .build()
2825            .expect("invalid params");
2826        let resolver = crate::config::endpoint::DefaultResolver::new();
2827        let endpoint = resolver.resolve_endpoint(&params);
2828        let error =
2829            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [endpoint override + non-dns bucket + FIPS (BUG)]");
2830        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2831    }
2832
2833    /// FIPS + bucket endpoint + 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(false)
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.us-east-1.amazonaws.com/bucket%21");
2848        assert_eq!(
2849            endpoint,
2850            ::aws_smithy_types::endpoint::Endpoint::builder()
2851                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
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    /// bucket + FIPS + force path style
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            .force_path_style(true)
2874            .use_fips(true)
2875            .use_dual_stack(true)
2876            .use_global_endpoint(true)
2877            .build()
2878            .expect("invalid params");
2879        let resolver = crate::config::endpoint::DefaultResolver::new();
2880        let endpoint = resolver.resolve_endpoint(&params);
2881        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket");
2882        assert_eq!(
2883            endpoint,
2884            ::aws_smithy_types::endpoint::Endpoint::builder()
2885                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket")
2886                .property(
2887                    "authSchemes",
2888                    vec![::aws_smithy_types::Document::from({
2889                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2890                        out.insert("name".to_string(), "sigv4".to_string().into());
2891                        out.insert("signingName".to_string(), "s3".to_string().into());
2892                        out.insert("disableDoubleEncoding".to_string(), true.into());
2893                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2894                        out
2895                    })]
2896                )
2897                .build()
2898        );
2899    }
2900
2901    /// FIPS + dualstack + use global endpoint
2902    #[test]
2903    fn test_100() {
2904        let params = crate::config::endpoint::Params::builder()
2905            .region("us-east-1".to_string())
2906            .bucket("bucket".to_string())
2907            .use_fips(true)
2908            .use_dual_stack(true)
2909            .use_global_endpoint(true)
2910            .build()
2911            .expect("invalid params");
2912        let resolver = crate::config::endpoint::DefaultResolver::new();
2913        let endpoint = resolver.resolve_endpoint(&params);
2914        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-fips.dualstack.us-east-1.amazonaws.com");
2915        assert_eq!(
2916            endpoint,
2917            ::aws_smithy_types::endpoint::Endpoint::builder()
2918                .url("https://bucket.s3-fips.dualstack.us-east-1.amazonaws.com")
2919                .property(
2920                    "authSchemes",
2921                    vec![::aws_smithy_types::Document::from({
2922                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2923                        out.insert("name".to_string(), "sigv4".to_string().into());
2924                        out.insert("signingName".to_string(), "s3".to_string().into());
2925                        out.insert("disableDoubleEncoding".to_string(), true.into());
2926                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2927                        out
2928                    })]
2929                )
2930                .build()
2931        );
2932    }
2933
2934    /// URI encoded bucket + use global endpoint
2935    #[test]
2936    fn test_101() {
2937        let params = crate::config::endpoint::Params::builder()
2938            .region("us-east-1".to_string())
2939            .bucket("bucket!".to_string())
2940            .use_fips(true)
2941            .use_dual_stack(false)
2942            .use_global_endpoint(true)
2943            .endpoint("https://foo.com".to_string())
2944            .build()
2945            .expect("invalid params");
2946        let resolver = crate::config::endpoint::DefaultResolver::new();
2947        let endpoint = resolver.resolve_endpoint(&params);
2948        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [URI encoded bucket + use global endpoint]");
2949        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2950    }
2951
2952    /// FIPS + path based 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(true)
2959            .use_dual_stack(false)
2960            .accelerate(false)
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://s3-fips.us-east-1.amazonaws.com/bucket%21");
2967        assert_eq!(
2968            endpoint,
2969            ::aws_smithy_types::endpoint::Endpoint::builder()
2970                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
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    /// accelerate + dualstack + global endpoint
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            .use_fips(false)
2993            .use_dual_stack(true)
2994            .accelerate(true)
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://bucket.s3-accelerate.dualstack.amazonaws.com");
3001        assert_eq!(
3002            endpoint,
3003            ::aws_smithy_types::endpoint::Endpoint::builder()
3004                .url("https://bucket.s3-accelerate.dualstack.amazonaws.com")
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    /// dualstack + global endpoint + non URI safe 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            .accelerate(false)
3027            .use_dual_stack(true)
3028            .use_fips(false)
3029            .use_global_endpoint(true)
3030            .build()
3031            .expect("invalid params");
3032        let resolver = crate::config::endpoint::DefaultResolver::new();
3033        let endpoint = resolver.resolve_endpoint(&params);
3034        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket%21");
3035        assert_eq!(
3036            endpoint,
3037            ::aws_smithy_types::endpoint::Endpoint::builder()
3038                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket%21")
3039                .property(
3040                    "authSchemes",
3041                    vec![::aws_smithy_types::Document::from({
3042                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3043                        out.insert("name".to_string(), "sigv4".to_string().into());
3044                        out.insert("signingName".to_string(), "s3".to_string().into());
3045                        out.insert("disableDoubleEncoding".to_string(), true.into());
3046                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3047                        out
3048                    })]
3049                )
3050                .build()
3051        );
3052    }
3053
3054    /// FIPS + uri encoded bucket
3055    #[test]
3056    fn test_105() {
3057        let params = crate::config::endpoint::Params::builder()
3058            .region("us-east-1".to_string())
3059            .bucket("bucket!".to_string())
3060            .force_path_style(true)
3061            .accelerate(false)
3062            .use_dual_stack(false)
3063            .use_fips(true)
3064            .use_global_endpoint(true)
3065            .build()
3066            .expect("invalid params");
3067        let resolver = crate::config::endpoint::DefaultResolver::new();
3068        let endpoint = resolver.resolve_endpoint(&params);
3069        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
3070        assert_eq!(
3071            endpoint,
3072            ::aws_smithy_types::endpoint::Endpoint::builder()
3073                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
3074                .property(
3075                    "authSchemes",
3076                    vec![::aws_smithy_types::Document::from({
3077                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3078                        out.insert("name".to_string(), "sigv4".to_string().into());
3079                        out.insert("signingName".to_string(), "s3".to_string().into());
3080                        out.insert("disableDoubleEncoding".to_string(), true.into());
3081                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3082                        out
3083                    })]
3084                )
3085                .build()
3086        );
3087    }
3088
3089    /// endpoint override + non-uri safe endpoint + force path style
3090    #[test]
3091    fn test_106() {
3092        let params = crate::config::endpoint::Params::builder()
3093            .region("us-east-1".to_string())
3094            .bucket("bucket!".to_string())
3095            .force_path_style(true)
3096            .accelerate(false)
3097            .use_dual_stack(false)
3098            .use_fips(true)
3099            .endpoint("http://foo.com".to_string())
3100            .use_global_endpoint(true)
3101            .build()
3102            .expect("invalid params");
3103        let resolver = crate::config::endpoint::DefaultResolver::new();
3104        let endpoint = resolver.resolve_endpoint(&params);
3105        let error = endpoint.expect_err(
3106            "expected error: A custom endpoint cannot be combined with FIPS [endpoint override + non-uri safe endpoint + force path style]",
3107        );
3108        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3109    }
3110
3111    /// FIPS + Dualstack + global endpoint + non-dns bucket
3112    #[test]
3113    fn test_107() {
3114        let params = crate::config::endpoint::Params::builder()
3115            .region("us-east-1".to_string())
3116            .bucket("bucket!".to_string())
3117            .accelerate(false)
3118            .use_dual_stack(true)
3119            .use_fips(true)
3120            .use_global_endpoint(true)
3121            .build()
3122            .expect("invalid params");
3123        let resolver = crate::config::endpoint::DefaultResolver::new();
3124        let endpoint = resolver.resolve_endpoint(&params);
3125        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
3126        assert_eq!(
3127            endpoint,
3128            ::aws_smithy_types::endpoint::Endpoint::builder()
3129                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
3130                .property(
3131                    "authSchemes",
3132                    vec![::aws_smithy_types::Document::from({
3133                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3134                        out.insert("name".to_string(), "sigv4".to_string().into());
3135                        out.insert("signingName".to_string(), "s3".to_string().into());
3136                        out.insert("disableDoubleEncoding".to_string(), true.into());
3137                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3138                        out
3139                    })]
3140                )
3141                .build()
3142        );
3143    }
3144
3145    /// endpoint override + FIPS + dualstack
3146    #[test]
3147    fn test_108() {
3148        let params = crate::config::endpoint::Params::builder()
3149            .region("us-east-1".to_string())
3150            .use_dual_stack(true)
3151            .use_fips(true)
3152            .use_global_endpoint(true)
3153            .endpoint("http://foo.com".to_string())
3154            .build()
3155            .expect("invalid params");
3156        let resolver = crate::config::endpoint::DefaultResolver::new();
3157        let endpoint = resolver.resolve_endpoint(&params);
3158        let error = endpoint
3159            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [endpoint override + FIPS + dualstack]");
3160        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3161    }
3162
3163    /// non-bucket endpoint override + dualstack + global endpoint
3164    #[test]
3165    fn test_109() {
3166        let params = crate::config::endpoint::Params::builder()
3167            .region("us-east-1".to_string())
3168            .use_fips(false)
3169            .use_dual_stack(true)
3170            .use_global_endpoint(true)
3171            .endpoint("http://foo.com".to_string())
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: Cannot set dual-stack in combination with a custom endpoint. [non-bucket endpoint override + dualstack + global endpoint]");
3177        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3178    }
3179
3180    /// Endpoint override + UseGlobalEndpoint + us-east-1
3181    #[test]
3182    fn test_110() {
3183        let params = crate::config::endpoint::Params::builder()
3184            .region("us-east-1".to_string())
3185            .use_fips(true)
3186            .use_dual_stack(false)
3187            .use_global_endpoint(true)
3188            .endpoint("http://foo.com".to_string())
3189            .build()
3190            .expect("invalid params");
3191        let resolver = crate::config::endpoint::DefaultResolver::new();
3192        let endpoint = resolver.resolve_endpoint(&params);
3193        let error =
3194            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [Endpoint override + UseGlobalEndpoint + us-east-1]");
3195        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3196    }
3197
3198    /// non-FIPS partition with FIPS set + custom endpoint
3199    #[test]
3200    fn test_111() {
3201        let params = crate::config::endpoint::Params::builder()
3202            .region("cn-north-1".to_string())
3203            .use_fips(true)
3204            .use_dual_stack(false)
3205            .use_global_endpoint(true)
3206            .build()
3207            .expect("invalid params");
3208        let resolver = crate::config::endpoint::DefaultResolver::new();
3209        let endpoint = resolver.resolve_endpoint(&params);
3210        let error = endpoint.expect_err("expected error: Partition does not support FIPS [non-FIPS partition with FIPS set + custom endpoint]");
3211        assert_eq!(format!("{}", error), "Partition does not support FIPS")
3212    }
3213
3214    /// aws-global signs as us-east-1
3215    #[test]
3216    fn test_112() {
3217        let params = crate::config::endpoint::Params::builder()
3218            .region("aws-global".to_string())
3219            .bucket("bucket!".to_string())
3220            .use_fips(true)
3221            .accelerate(false)
3222            .use_dual_stack(true)
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://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
3228        assert_eq!(
3229            endpoint,
3230            ::aws_smithy_types::endpoint::Endpoint::builder()
3231                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
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 signs as us-east-1
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(false)
3254            .use_fips(false)
3255            .accelerate(false)
3256            .endpoint("https://foo.com".to_string())
3257            .build()
3258            .expect("invalid params");
3259        let resolver = crate::config::endpoint::DefaultResolver::new();
3260        let endpoint = resolver.resolve_endpoint(&params);
3261        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.foo.com");
3262        assert_eq!(
3263            endpoint,
3264            ::aws_smithy_types::endpoint::Endpoint::builder()
3265                .url("https://bucket.foo.com")
3266                .property(
3267                    "authSchemes",
3268                    vec![::aws_smithy_types::Document::from({
3269                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3270                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3271                        out.insert("name".to_string(), "sigv4".to_string().into());
3272                        out.insert("signingName".to_string(), "s3".to_string().into());
3273                        out.insert("disableDoubleEncoding".to_string(), true.into());
3274                        out
3275                    })]
3276                )
3277                .build()
3278        );
3279    }
3280
3281    /// aws-global + dualstack + path-only bucket
3282    #[test]
3283    fn test_114() {
3284        let params = crate::config::endpoint::Params::builder()
3285            .region("aws-global".to_string())
3286            .bucket("bucket!".to_string())
3287            .use_dual_stack(true)
3288            .use_fips(false)
3289            .accelerate(false)
3290            .build()
3291            .expect("invalid params");
3292        let resolver = crate::config::endpoint::DefaultResolver::new();
3293        let endpoint = resolver.resolve_endpoint(&params);
3294        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket%21");
3295        assert_eq!(
3296            endpoint,
3297            ::aws_smithy_types::endpoint::Endpoint::builder()
3298                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket%21")
3299                .property(
3300                    "authSchemes",
3301                    vec![::aws_smithy_types::Document::from({
3302                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3303                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3304                        out.insert("name".to_string(), "sigv4".to_string().into());
3305                        out.insert("signingName".to_string(), "s3".to_string().into());
3306                        out.insert("disableDoubleEncoding".to_string(), true.into());
3307                        out
3308                    })]
3309                )
3310                .build()
3311        );
3312    }
3313
3314    /// aws-global + path-only bucket
3315    #[test]
3316    fn test_115() {
3317        let params = crate::config::endpoint::Params::builder()
3318            .region("aws-global".to_string())
3319            .bucket("bucket!".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 endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket%21");
3325        assert_eq!(
3326            endpoint,
3327            ::aws_smithy_types::endpoint::Endpoint::builder()
3328                .url("https://s3.amazonaws.com/bucket%21")
3329                .property(
3330                    "authSchemes",
3331                    vec![::aws_smithy_types::Document::from({
3332                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3333                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3334                        out.insert("name".to_string(), "sigv4".to_string().into());
3335                        out.insert("signingName".to_string(), "s3".to_string().into());
3336                        out.insert("disableDoubleEncoding".to_string(), true.into());
3337                        out
3338                    })]
3339                )
3340                .build()
3341        );
3342    }
3343
3344    /// aws-global + fips + custom endpoint
3345    #[test]
3346    fn test_116() {
3347        let params = crate::config::endpoint::Params::builder()
3348            .region("aws-global".to_string())
3349            .bucket("bucket!".to_string())
3350            .use_dual_stack(false)
3351            .use_fips(true)
3352            .accelerate(false)
3353            .endpoint("http://foo.com".to_string())
3354            .build()
3355            .expect("invalid params");
3356        let resolver = crate::config::endpoint::DefaultResolver::new();
3357        let endpoint = resolver.resolve_endpoint(&params);
3358        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [aws-global + fips + custom endpoint]");
3359        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3360    }
3361
3362    /// aws-global, endpoint override & path only-bucket
3363    #[test]
3364    fn test_117() {
3365        let params = crate::config::endpoint::Params::builder()
3366            .region("aws-global".to_string())
3367            .bucket("bucket!".to_string())
3368            .use_dual_stack(false)
3369            .use_fips(false)
3370            .accelerate(false)
3371            .endpoint("http://foo.com".to_string())
3372            .build()
3373            .expect("invalid params");
3374        let resolver = crate::config::endpoint::DefaultResolver::new();
3375        let endpoint = resolver.resolve_endpoint(&params);
3376        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
3377        assert_eq!(
3378            endpoint,
3379            ::aws_smithy_types::endpoint::Endpoint::builder()
3380                .url("http://foo.com/bucket%21")
3381                .property(
3382                    "authSchemes",
3383                    vec![::aws_smithy_types::Document::from({
3384                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3385                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3386                        out.insert("name".to_string(), "sigv4".to_string().into());
3387                        out.insert("signingName".to_string(), "s3".to_string().into());
3388                        out.insert("disableDoubleEncoding".to_string(), true.into());
3389                        out
3390                    })]
3391                )
3392                .build()
3393        );
3394    }
3395
3396    /// aws-global + dualstack + custom endpoint
3397    #[test]
3398    fn test_118() {
3399        let params = crate::config::endpoint::Params::builder()
3400            .region("aws-global".to_string())
3401            .use_dual_stack(true)
3402            .use_fips(false)
3403            .accelerate(false)
3404            .endpoint("http://foo.com".to_string())
3405            .build()
3406            .expect("invalid params");
3407        let resolver = crate::config::endpoint::DefaultResolver::new();
3408        let endpoint = resolver.resolve_endpoint(&params);
3409        let error = endpoint
3410            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [aws-global + dualstack + custom endpoint]");
3411        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3412    }
3413
3414    /// accelerate, dualstack + aws-global
3415    #[test]
3416    fn test_119() {
3417        let params = crate::config::endpoint::Params::builder()
3418            .region("aws-global".to_string())
3419            .bucket("bucket".to_string())
3420            .use_dual_stack(true)
3421            .use_fips(false)
3422            .accelerate(true)
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://bucket.s3-accelerate.dualstack.us-east-1.amazonaws.com");
3428        assert_eq!(
3429            endpoint,
3430            ::aws_smithy_types::endpoint::Endpoint::builder()
3431                .url("https://bucket.s3-accelerate.dualstack.us-east-1.amazonaws.com")
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    /// FIPS + aws-global + path only bucket. This is not supported by S3 but we allow garbage in garbage out
3448    #[test]
3449    fn test_120() {
3450        let params = crate::config::endpoint::Params::builder()
3451            .region("aws-global".to_string())
3452            .bucket("bucket!".to_string())
3453            .force_path_style(true)
3454            .use_dual_stack(true)
3455            .use_fips(true)
3456            .accelerate(false)
3457            .build()
3458            .expect("invalid params");
3459        let resolver = crate::config::endpoint::DefaultResolver::new();
3460        let endpoint = resolver.resolve_endpoint(&params);
3461        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
3462        assert_eq!(
3463            endpoint,
3464            ::aws_smithy_types::endpoint::Endpoint::builder()
3465                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
3466                .property(
3467                    "authSchemes",
3468                    vec![::aws_smithy_types::Document::from({
3469                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3470                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3471                        out.insert("name".to_string(), "sigv4".to_string().into());
3472                        out.insert("signingName".to_string(), "s3".to_string().into());
3473                        out.insert("disableDoubleEncoding".to_string(), true.into());
3474                        out
3475                    })]
3476                )
3477                .build()
3478        );
3479    }
3480
3481    /// aws-global + FIPS + endpoint override.
3482    #[test]
3483    fn test_121() {
3484        let params = crate::config::endpoint::Params::builder()
3485            .region("aws-global".to_string())
3486            .use_fips(true)
3487            .endpoint("http://foo.com".to_string())
3488            .build()
3489            .expect("invalid params");
3490        let resolver = crate::config::endpoint::DefaultResolver::new();
3491        let endpoint = resolver.resolve_endpoint(&params);
3492        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [aws-global + FIPS + endpoint override.]");
3493        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3494    }
3495
3496    /// force path style, FIPS, aws-global & endpoint override
3497    #[test]
3498    fn test_122() {
3499        let params = crate::config::endpoint::Params::builder()
3500            .region("aws-global".to_string())
3501            .bucket("bucket!".to_string())
3502            .force_path_style(true)
3503            .use_fips(true)
3504            .endpoint("http://foo.com".to_string())
3505            .build()
3506            .expect("invalid params");
3507        let resolver = crate::config::endpoint::DefaultResolver::new();
3508        let endpoint = resolver.resolve_endpoint(&params);
3509        let error = endpoint
3510            .expect_err("expected error: A custom endpoint cannot be combined with FIPS [force path style, FIPS, aws-global & endpoint override]");
3511        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3512    }
3513
3514    /// ip address causes path style to be forced
3515    #[test]
3516    fn test_123() {
3517        let params = crate::config::endpoint::Params::builder()
3518            .region("aws-global".to_string())
3519            .bucket("bucket".to_string())
3520            .endpoint("http://192.168.1.1".to_string())
3521            .build()
3522            .expect("invalid params");
3523        let resolver = crate::config::endpoint::DefaultResolver::new();
3524        let endpoint = resolver.resolve_endpoint(&params);
3525        let endpoint = endpoint.expect("Expected valid endpoint: http://192.168.1.1/bucket");
3526        assert_eq!(
3527            endpoint,
3528            ::aws_smithy_types::endpoint::Endpoint::builder()
3529                .url("http://192.168.1.1/bucket")
3530                .property(
3531                    "authSchemes",
3532                    vec![::aws_smithy_types::Document::from({
3533                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3534                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3535                        out.insert("name".to_string(), "sigv4".to_string().into());
3536                        out.insert("signingName".to_string(), "s3".to_string().into());
3537                        out.insert("disableDoubleEncoding".to_string(), true.into());
3538                        out
3539                    })]
3540                )
3541                .build()
3542        );
3543    }
3544
3545    /// endpoint override with aws-global region
3546    #[test]
3547    fn test_124() {
3548        let params = crate::config::endpoint::Params::builder()
3549            .region("aws-global".to_string())
3550            .use_fips(true)
3551            .use_dual_stack(true)
3552            .endpoint("http://foo.com".to_string())
3553            .build()
3554            .expect("invalid params");
3555        let resolver = crate::config::endpoint::DefaultResolver::new();
3556        let endpoint = resolver.resolve_endpoint(&params);
3557        let error = endpoint
3558            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [endpoint override with aws-global region]");
3559        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3560    }
3561
3562    /// FIPS + path-only (TODO: consider making this an error)
3563    #[test]
3564    fn test_125() {
3565        let params = crate::config::endpoint::Params::builder()
3566            .region("aws-global".to_string())
3567            .bucket("bucket!".to_string())
3568            .use_fips(true)
3569            .build()
3570            .expect("invalid params");
3571        let resolver = crate::config::endpoint::DefaultResolver::new();
3572        let endpoint = resolver.resolve_endpoint(&params);
3573        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
3574        assert_eq!(
3575            endpoint,
3576            ::aws_smithy_types::endpoint::Endpoint::builder()
3577                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
3578                .property(
3579                    "authSchemes",
3580                    vec![::aws_smithy_types::Document::from({
3581                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3582                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3583                        out.insert("name".to_string(), "sigv4".to_string().into());
3584                        out.insert("signingName".to_string(), "s3".to_string().into());
3585                        out.insert("disableDoubleEncoding".to_string(), true.into());
3586                        out
3587                    })]
3588                )
3589                .build()
3590        );
3591    }
3592
3593    /// empty arn type
3594    #[test]
3595    fn test_126() {
3596        let params = crate::config::endpoint::Params::builder()
3597            .region("us-east-2".to_string())
3598            .bucket("arn:aws:not-s3:us-west-2:123456789012::myendpoint".to_string())
3599            .build()
3600            .expect("invalid params");
3601        let resolver = crate::config::endpoint::DefaultResolver::new();
3602        let endpoint = resolver.resolve_endpoint(&params);
3603        let error = endpoint.expect_err("expected error: Invalid ARN: No ARN type specified [empty arn type]");
3604        assert_eq!(format!("{}", error), "Invalid ARN: No ARN type specified")
3605    }
3606
3607    /// path style can't be used with accelerate
3608    #[test]
3609    fn test_127() {
3610        let params = crate::config::endpoint::Params::builder()
3611            .region("us-east-2".to_string())
3612            .bucket("bucket!".to_string())
3613            .accelerate(true)
3614            .build()
3615            .expect("invalid params");
3616        let resolver = crate::config::endpoint::DefaultResolver::new();
3617        let endpoint = resolver.resolve_endpoint(&params);
3618        let error =
3619            endpoint.expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style can't be used with accelerate]");
3620        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
3621    }
3622
3623    /// invalid region
3624    #[test]
3625    fn test_128() {
3626        let params = crate::config::endpoint::Params::builder()
3627            .region("us-east-2!".to_string())
3628            .bucket("bucket.subdomain".to_string())
3629            .endpoint("http://foo.com".to_string())
3630            .build()
3631            .expect("invalid params");
3632        let resolver = crate::config::endpoint::DefaultResolver::new();
3633        let endpoint = resolver.resolve_endpoint(&params);
3634        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [invalid region]");
3635        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
3636    }
3637
3638    /// invalid region
3639    #[test]
3640    fn test_129() {
3641        let params = crate::config::endpoint::Params::builder()
3642            .region("us-east-2!".to_string())
3643            .bucket("bucket".to_string())
3644            .endpoint("http://foo.com".to_string())
3645            .build()
3646            .expect("invalid params");
3647        let resolver = crate::config::endpoint::DefaultResolver::new();
3648        let endpoint = resolver.resolve_endpoint(&params);
3649        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [invalid region]");
3650        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
3651    }
3652
3653    /// empty arn type
3654    #[test]
3655    fn test_130() {
3656        let params = crate::config::endpoint::Params::builder()
3657            .region("us-east-2".to_string())
3658            .bucket("arn:aws:s3::123456789012:accesspoint:my_endpoint".to_string())
3659            .build()
3660            .expect("invalid params");
3661        let resolver = crate::config::endpoint::DefaultResolver::new();
3662        let endpoint = resolver.resolve_endpoint(&params);
3663        let error = endpoint.expect_err("expected error: Invalid Access Point Name [empty arn type]");
3664        assert_eq!(format!("{}", error), "Invalid Access Point Name")
3665    }
3666
3667    /// empty arn type
3668    #[test]
3669    fn test_131() {
3670        let params = crate::config::endpoint::Params::builder()
3671            .region("us-east-2".to_string())
3672            .bucket("arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint".to_string())
3673            .use_arn_region(true)
3674            .build()
3675            .expect("invalid params");
3676        let resolver = crate::config::endpoint::DefaultResolver::new();
3677        let endpoint = resolver.resolve_endpoint(&params);
3678        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]");
3679        assert_eq!(
3680            format!("{}", error),
3681            "Client was configured for partition `aws` but ARN (`arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint`) has `aws-cn`"
3682        )
3683    }
3684
3685    /// invalid arn region
3686    #[test]
3687    fn test_132() {
3688        let params = crate::config::endpoint::Params::builder()
3689            .region("us-east-2".to_string())
3690            .bucket("arn:aws:s3-object-lambda:us-east_2:123456789012:accesspoint:my-endpoint".to_string())
3691            .use_arn_region(true)
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 region in ARN: `us-east_2` (invalid DNS name) [invalid arn region]");
3697        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-east_2` (invalid DNS name)")
3698    }
3699
3700    /// invalid ARN outpost
3701    #[test]
3702    fn test_133() {
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/accesspoint/reports".to_string())
3706            .use_arn_region(true)
3707            .build()
3708            .expect("invalid params");
3709        let resolver = crate::config::endpoint::DefaultResolver::new();
3710        let endpoint = resolver.resolve_endpoint(&params);
3711        let error = endpoint.expect_err(
3712            "expected error: Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `op_01234567890123456` [invalid ARN outpost]",
3713        );
3714        assert_eq!(
3715            format!("{}", error),
3716            "Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `op_01234567890123456`"
3717        )
3718    }
3719
3720    /// invalid ARN
3721    #[test]
3722    fn test_134() {
3723        let params = crate::config::endpoint::Params::builder()
3724            .region("us-east-2".to_string())
3725            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/reports".to_string())
3726            .build()
3727            .expect("invalid params");
3728        let resolver = crate::config::endpoint::DefaultResolver::new();
3729        let endpoint = resolver.resolve_endpoint(&params);
3730        let error = endpoint.expect_err("expected error: Invalid ARN: expected an access point name [invalid ARN]");
3731        assert_eq!(format!("{}", error), "Invalid ARN: expected an access point name")
3732    }
3733
3734    /// invalid ARN
3735    #[test]
3736    fn test_135() {
3737        let params = crate::config::endpoint::Params::builder()
3738            .region("us-east-2".to_string())
3739            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456".to_string())
3740            .build()
3741            .expect("invalid params");
3742        let resolver = crate::config::endpoint::DefaultResolver::new();
3743        let endpoint = resolver.resolve_endpoint(&params);
3744        let error = endpoint.expect_err("expected error: Invalid ARN: Expected a 4-component resource [invalid ARN]");
3745        assert_eq!(format!("{}", error), "Invalid ARN: Expected a 4-component resource")
3746    }
3747
3748    /// invalid outpost type
3749    #[test]
3750    fn test_136() {
3751        let params = crate::config::endpoint::Params::builder()
3752            .region("us-east-2".to_string())
3753            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3754            .build()
3755            .expect("invalid params");
3756        let resolver = crate::config::endpoint::DefaultResolver::new();
3757        let endpoint = resolver.resolve_endpoint(&params);
3758        let error = endpoint.expect_err("expected error: Expected an outpost type `accesspoint`, found not-accesspoint [invalid outpost type]");
3759        assert_eq!(format!("{}", error), "Expected an outpost type `accesspoint`, found not-accesspoint")
3760    }
3761
3762    /// invalid outpost type
3763    #[test]
3764    fn test_137() {
3765        let params = crate::config::endpoint::Params::builder()
3766            .region("us-east-2".to_string())
3767            .bucket("arn:aws:s3-outposts:us-east_1:123456789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3768            .build()
3769            .expect("invalid params");
3770        let resolver = crate::config::endpoint::DefaultResolver::new();
3771        let endpoint = resolver.resolve_endpoint(&params);
3772        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-east_1` (invalid DNS name) [invalid outpost type]");
3773        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-east_1` (invalid DNS name)")
3774    }
3775
3776    /// invalid outpost type
3777    #[test]
3778    fn test_138() {
3779        let params = crate::config::endpoint::Params::builder()
3780            .region("us-east-2".to_string())
3781            .bucket("arn:aws:s3-outposts:us-east-1:12345_789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3782            .build()
3783            .expect("invalid params");
3784        let resolver = crate::config::endpoint::DefaultResolver::new();
3785        let endpoint = resolver.resolve_endpoint(&params);
3786        let error = endpoint.expect_err(
3787            "expected error: Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `12345_789012` [invalid outpost type]",
3788        );
3789        assert_eq!(
3790            format!("{}", error),
3791            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `12345_789012`"
3792        )
3793    }
3794
3795    /// invalid outpost type
3796    #[test]
3797    fn test_139() {
3798        let params = crate::config::endpoint::Params::builder()
3799            .region("us-east-2".to_string())
3800            .bucket("arn:aws:s3-outposts:us-east-1:12345789012:outpost".to_string())
3801            .build()
3802            .expect("invalid params");
3803        let resolver = crate::config::endpoint::DefaultResolver::new();
3804        let endpoint = resolver.resolve_endpoint(&params);
3805        let error = endpoint.expect_err("expected error: Invalid ARN: The Outpost Id was not set [invalid outpost type]");
3806        assert_eq!(format!("{}", error), "Invalid ARN: The Outpost Id was not set")
3807    }
3808
3809    /// use global endpoint virtual addressing
3810    #[test]
3811    fn test_140() {
3812        let params = crate::config::endpoint::Params::builder()
3813            .region("us-east-2".to_string())
3814            .bucket("bucket".to_string())
3815            .endpoint("http://example.com".to_string())
3816            .use_global_endpoint(true)
3817            .build()
3818            .expect("invalid params");
3819        let resolver = crate::config::endpoint::DefaultResolver::new();
3820        let endpoint = resolver.resolve_endpoint(&params);
3821        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket.example.com");
3822        assert_eq!(
3823            endpoint,
3824            ::aws_smithy_types::endpoint::Endpoint::builder()
3825                .url("http://bucket.example.com")
3826                .property(
3827                    "authSchemes",
3828                    vec![::aws_smithy_types::Document::from({
3829                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3830                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3831                        out.insert("name".to_string(), "sigv4".to_string().into());
3832                        out.insert("signingName".to_string(), "s3".to_string().into());
3833                        out.insert("disableDoubleEncoding".to_string(), true.into());
3834                        out
3835                    })]
3836                )
3837                .build()
3838        );
3839    }
3840
3841    /// global endpoint + ip address
3842    #[test]
3843    fn test_141() {
3844        let params = crate::config::endpoint::Params::builder()
3845            .region("us-east-2".to_string())
3846            .bucket("bucket".to_string())
3847            .endpoint("http://192.168.0.1".to_string())
3848            .use_global_endpoint(true)
3849            .build()
3850            .expect("invalid params");
3851        let resolver = crate::config::endpoint::DefaultResolver::new();
3852        let endpoint = resolver.resolve_endpoint(&params);
3853        let endpoint = endpoint.expect("Expected valid endpoint: http://192.168.0.1/bucket");
3854        assert_eq!(
3855            endpoint,
3856            ::aws_smithy_types::endpoint::Endpoint::builder()
3857                .url("http://192.168.0.1/bucket")
3858                .property(
3859                    "authSchemes",
3860                    vec![::aws_smithy_types::Document::from({
3861                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3862                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3863                        out.insert("name".to_string(), "sigv4".to_string().into());
3864                        out.insert("signingName".to_string(), "s3".to_string().into());
3865                        out.insert("disableDoubleEncoding".to_string(), true.into());
3866                        out
3867                    })]
3868                )
3869                .build()
3870        );
3871    }
3872
3873    /// invalid outpost type
3874    #[test]
3875    fn test_142() {
3876        let params = crate::config::endpoint::Params::builder()
3877            .region("us-east-2".to_string())
3878            .bucket("bucket!".to_string())
3879            .use_global_endpoint(true)
3880            .build()
3881            .expect("invalid params");
3882        let resolver = crate::config::endpoint::DefaultResolver::new();
3883        let endpoint = resolver.resolve_endpoint(&params);
3884        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-2.amazonaws.com/bucket%21");
3885        assert_eq!(
3886            endpoint,
3887            ::aws_smithy_types::endpoint::Endpoint::builder()
3888                .url("https://s3.us-east-2.amazonaws.com/bucket%21")
3889                .property(
3890                    "authSchemes",
3891                    vec![::aws_smithy_types::Document::from({
3892                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3893                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3894                        out.insert("name".to_string(), "sigv4".to_string().into());
3895                        out.insert("signingName".to_string(), "s3".to_string().into());
3896                        out.insert("disableDoubleEncoding".to_string(), true.into());
3897                        out
3898                    })]
3899                )
3900                .build()
3901        );
3902    }
3903
3904    /// invalid outpost type
3905    #[test]
3906    fn test_143() {
3907        let params = crate::config::endpoint::Params::builder()
3908            .region("us-east-2".to_string())
3909            .bucket("bucket".to_string())
3910            .accelerate(true)
3911            .use_global_endpoint(true)
3912            .build()
3913            .expect("invalid params");
3914        let resolver = crate::config::endpoint::DefaultResolver::new();
3915        let endpoint = resolver.resolve_endpoint(&params);
3916        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.amazonaws.com");
3917        assert_eq!(
3918            endpoint,
3919            ::aws_smithy_types::endpoint::Endpoint::builder()
3920                .url("https://bucket.s3-accelerate.amazonaws.com")
3921                .property(
3922                    "authSchemes",
3923                    vec![::aws_smithy_types::Document::from({
3924                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3925                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3926                        out.insert("name".to_string(), "sigv4".to_string().into());
3927                        out.insert("signingName".to_string(), "s3".to_string().into());
3928                        out.insert("disableDoubleEncoding".to_string(), true.into());
3929                        out
3930                    })]
3931                )
3932                .build()
3933        );
3934    }
3935
3936    /// use global endpoint + custom endpoint
3937    #[test]
3938    fn test_144() {
3939        let params = crate::config::endpoint::Params::builder()
3940            .region("us-east-2".to_string())
3941            .bucket("bucket!".to_string())
3942            .use_global_endpoint(true)
3943            .endpoint("http://foo.com".to_string())
3944            .build()
3945            .expect("invalid params");
3946        let resolver = crate::config::endpoint::DefaultResolver::new();
3947        let endpoint = resolver.resolve_endpoint(&params);
3948        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
3949        assert_eq!(
3950            endpoint,
3951            ::aws_smithy_types::endpoint::Endpoint::builder()
3952                .url("http://foo.com/bucket%21")
3953                .property(
3954                    "authSchemes",
3955                    vec![::aws_smithy_types::Document::from({
3956                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3957                        out.insert("signingRegion".to_string(), "us-east-2".to_string().into());
3958                        out.insert("name".to_string(), "sigv4".to_string().into());
3959                        out.insert("signingName".to_string(), "s3".to_string().into());
3960                        out.insert("disableDoubleEncoding".to_string(), true.into());
3961                        out
3962                    })]
3963                )
3964                .build()
3965        );
3966    }
3967
3968    /// use global endpoint, not us-east-1, force path style
3969    #[test]
3970    fn test_145() {
3971        let params = crate::config::endpoint::Params::builder()
3972            .region("us-east-2".to_string())
3973            .bucket("bucket!".to_string())
3974            .use_global_endpoint(true)
3975            .force_path_style(true)
3976            .endpoint("http://foo.com".to_string())
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: http://foo.com/bucket%21");
3982        assert_eq!(
3983            endpoint,
3984            ::aws_smithy_types::endpoint::Endpoint::builder()
3985                .url("http://foo.com/bucket%21")
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("signingRegion".to_string(), "us-east-2".to_string().into());
3991                        out.insert("name".to_string(), "sigv4".to_string().into());
3992                        out.insert("signingName".to_string(), "s3".to_string().into());
3993                        out.insert("disableDoubleEncoding".to_string(), true.into());
3994                        out
3995                    })]
3996                )
3997                .build()
3998        );
3999    }
4000
4001    /// vanilla virtual addressing@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(false)
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.us-west-2.amazonaws.com");
4016        assert_eq!(
4017            endpoint,
4018            ::aws_smithy_types::endpoint::Endpoint::builder()
4019                .url("https://bucket-name.s3.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    /// virtual addressing + dualstack@us-west-2
4036    #[test]
4037    fn test_147() {
4038        let params = crate::config::endpoint::Params::builder()
4039            .accelerate(false)
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.dualstack.us-west-2.amazonaws.com");
4050        assert_eq!(
4051            endpoint,
4052            ::aws_smithy_types::endpoint::Endpoint::builder()
4053                .url("https://bucket-name.s3.dualstack.us-west-2.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@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(true)
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.dualstack.amazonaws.com");
4084        assert_eq!(
4085            endpoint,
4086            ::aws_smithy_types::endpoint::Endpoint::builder()
4087                .url("https://bucket-name.s3-accelerate.dualstack.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    /// accelerate (dualstack=false)@us-west-2
4104    #[test]
4105    fn test_149() {
4106        let params = crate::config::endpoint::Params::builder()
4107            .accelerate(true)
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(false)
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-accelerate.amazonaws.com");
4118        assert_eq!(
4119            endpoint,
4120            ::aws_smithy_types::endpoint::Endpoint::builder()
4121                .url("https://bucket-name.s3-accelerate.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 + 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(false)
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.us-west-2.amazonaws.com");
4152        assert_eq!(
4153            endpoint,
4154            ::aws_smithy_types::endpoint::Endpoint::builder()
4155                .url("https://bucket-name.s3-fips.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    /// virtual addressing + dualstack + fips@us-west-2
4172    #[test]
4173    fn test_151() {
4174        let params = crate::config::endpoint::Params::builder()
4175            .accelerate(false)
4176            .bucket("bucket-name".to_string())
4177            .force_path_style(false)
4178            .region("us-west-2".to_string())
4179            .use_dual_stack(true)
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 endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.us-west-2.amazonaws.com");
4186        assert_eq!(
4187            endpoint,
4188            ::aws_smithy_types::endpoint::Endpoint::builder()
4189                .url("https://bucket-name.s3-fips.dualstack.us-west-2.amazonaws.com")
4190                .property(
4191                    "authSchemes",
4192                    vec![::aws_smithy_types::Document::from({
4193                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4194                        out.insert("name".to_string(), "sigv4".to_string().into());
4195                        out.insert("signingName".to_string(), "s3".to_string().into());
4196                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4197                        out.insert("disableDoubleEncoding".to_string(), true.into());
4198                        out
4199                    })]
4200                )
4201                .build()
4202        );
4203    }
4204
4205    /// accelerate + fips = error@us-west-2
4206    #[test]
4207    fn test_152() {
4208        let params = crate::config::endpoint::Params::builder()
4209            .accelerate(true)
4210            .bucket("bucket-name".to_string())
4211            .force_path_style(false)
4212            .region("us-west-2".to_string())
4213            .use_dual_stack(false)
4214            .use_fips(true)
4215            .build()
4216            .expect("invalid params");
4217        let resolver = crate::config::endpoint::DefaultResolver::new();
4218        let endpoint = resolver.resolve_endpoint(&params);
4219        let error = endpoint.expect_err("expected error: Accelerate cannot be used with FIPS [accelerate + fips = error@us-west-2]");
4220        assert_eq!(format!("{}", error), "Accelerate cannot be used with FIPS")
4221    }
4222
4223    /// vanilla virtual addressing@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(false)
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.cn-north-1.amazonaws.com.cn");
4238        assert_eq!(
4239            endpoint,
4240            ::aws_smithy_types::endpoint::Endpoint::builder()
4241                .url("https://bucket-name.s3.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    /// virtual addressing + dualstack@cn-north-1
4258    #[test]
4259    fn test_154() {
4260        let params = crate::config::endpoint::Params::builder()
4261            .accelerate(false)
4262            .bucket("bucket-name".to_string())
4263            .force_path_style(false)
4264            .region("cn-north-1".to_string())
4265            .use_dual_stack(true)
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 endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.cn-north-1.amazonaws.com.cn");
4272        assert_eq!(
4273            endpoint,
4274            ::aws_smithy_types::endpoint::Endpoint::builder()
4275                .url("https://bucket-name.s3.dualstack.cn-north-1.amazonaws.com.cn")
4276                .property(
4277                    "authSchemes",
4278                    vec![::aws_smithy_types::Document::from({
4279                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4280                        out.insert("name".to_string(), "sigv4".to_string().into());
4281                        out.insert("signingName".to_string(), "s3".to_string().into());
4282                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4283                        out.insert("disableDoubleEncoding".to_string(), true.into());
4284                        out
4285                    })]
4286                )
4287                .build()
4288        );
4289    }
4290
4291    /// accelerate (dualstack=false)@cn-north-1
4292    #[test]
4293    fn test_155() {
4294        let params = crate::config::endpoint::Params::builder()
4295            .accelerate(true)
4296            .bucket("bucket-name".to_string())
4297            .force_path_style(false)
4298            .region("cn-north-1".to_string())
4299            .use_dual_stack(false)
4300            .use_fips(false)
4301            .build()
4302            .expect("invalid params");
4303        let resolver = crate::config::endpoint::DefaultResolver::new();
4304        let endpoint = resolver.resolve_endpoint(&params);
4305        let error = endpoint.expect_err("expected error: S3 Accelerate cannot be used in this region [accelerate (dualstack=false)@cn-north-1]");
4306        assert_eq!(format!("{}", error), "S3 Accelerate cannot be used in this region")
4307    }
4308
4309    /// virtual addressing + fips@cn-north-1
4310    #[test]
4311    fn test_156() {
4312        let params = crate::config::endpoint::Params::builder()
4313            .accelerate(false)
4314            .bucket("bucket-name".to_string())
4315            .force_path_style(false)
4316            .region("cn-north-1".to_string())
4317            .use_dual_stack(false)
4318            .use_fips(true)
4319            .build()
4320            .expect("invalid params");
4321        let resolver = crate::config::endpoint::DefaultResolver::new();
4322        let endpoint = resolver.resolve_endpoint(&params);
4323        let error = endpoint.expect_err("expected error: Partition does not support FIPS [virtual addressing + fips@cn-north-1]");
4324        assert_eq!(format!("{}", error), "Partition does not support FIPS")
4325    }
4326
4327    /// vanilla virtual addressing@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(false)
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.af-south-1.amazonaws.com");
4342        assert_eq!(
4343            endpoint,
4344            ::aws_smithy_types::endpoint::Endpoint::builder()
4345                .url("https://bucket-name.s3.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    /// virtual addressing + dualstack@af-south-1
4362    #[test]
4363    fn test_158() {
4364        let params = crate::config::endpoint::Params::builder()
4365            .accelerate(false)
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.dualstack.af-south-1.amazonaws.com");
4376        assert_eq!(
4377            endpoint,
4378            ::aws_smithy_types::endpoint::Endpoint::builder()
4379                .url("https://bucket-name.s3.dualstack.af-south-1.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@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(true)
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.dualstack.amazonaws.com");
4410        assert_eq!(
4411            endpoint,
4412            ::aws_smithy_types::endpoint::Endpoint::builder()
4413                .url("https://bucket-name.s3-accelerate.dualstack.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    /// accelerate (dualstack=false)@af-south-1
4430    #[test]
4431    fn test_160() {
4432        let params = crate::config::endpoint::Params::builder()
4433            .accelerate(true)
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(false)
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-accelerate.amazonaws.com");
4444        assert_eq!(
4445            endpoint,
4446            ::aws_smithy_types::endpoint::Endpoint::builder()
4447                .url("https://bucket-name.s3-accelerate.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 + 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(false)
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.af-south-1.amazonaws.com");
4478        assert_eq!(
4479            endpoint,
4480            ::aws_smithy_types::endpoint::Endpoint::builder()
4481                .url("https://bucket-name.s3-fips.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    /// virtual addressing + dualstack + fips@af-south-1
4498    #[test]
4499    fn test_162() {
4500        let params = crate::config::endpoint::Params::builder()
4501            .accelerate(false)
4502            .bucket("bucket-name".to_string())
4503            .force_path_style(false)
4504            .region("af-south-1".to_string())
4505            .use_dual_stack(true)
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 endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.af-south-1.amazonaws.com");
4512        assert_eq!(
4513            endpoint,
4514            ::aws_smithy_types::endpoint::Endpoint::builder()
4515                .url("https://bucket-name.s3-fips.dualstack.af-south-1.amazonaws.com")
4516                .property(
4517                    "authSchemes",
4518                    vec![::aws_smithy_types::Document::from({
4519                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4520                        out.insert("name".to_string(), "sigv4".to_string().into());
4521                        out.insert("signingName".to_string(), "s3".to_string().into());
4522                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4523                        out.insert("disableDoubleEncoding".to_string(), true.into());
4524                        out
4525                    })]
4526                )
4527                .build()
4528        );
4529    }
4530
4531    /// accelerate + fips = error@af-south-1
4532    #[test]
4533    fn test_163() {
4534        let params = crate::config::endpoint::Params::builder()
4535            .accelerate(true)
4536            .bucket("bucket-name".to_string())
4537            .force_path_style(false)
4538            .region("af-south-1".to_string())
4539            .use_dual_stack(false)
4540            .use_fips(true)
4541            .build()
4542            .expect("invalid params");
4543        let resolver = crate::config::endpoint::DefaultResolver::new();
4544        let endpoint = resolver.resolve_endpoint(&params);
4545        let error = endpoint.expect_err("expected error: Accelerate cannot be used with FIPS [accelerate + fips = error@af-south-1]");
4546        assert_eq!(format!("{}", error), "Accelerate cannot be used with FIPS")
4547    }
4548
4549    /// vanilla path style@us-west-2
4550    #[test]
4551    fn test_164() {
4552        let params = crate::config::endpoint::Params::builder()
4553            .accelerate(false)
4554            .bucket("bucket-name".to_string())
4555            .force_path_style(true)
4556            .region("us-west-2".to_string())
4557            .use_dual_stack(false)
4558            .use_fips(false)
4559            .build()
4560            .expect("invalid params");
4561        let resolver = crate::config::endpoint::DefaultResolver::new();
4562        let endpoint = resolver.resolve_endpoint(&params);
4563        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket-name");
4564        assert_eq!(
4565            endpoint,
4566            ::aws_smithy_types::endpoint::Endpoint::builder()
4567                .url("https://s3.us-west-2.amazonaws.com/bucket-name")
4568                .property(
4569                    "authSchemes",
4570                    vec![::aws_smithy_types::Document::from({
4571                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4572                        out.insert("name".to_string(), "sigv4".to_string().into());
4573                        out.insert("signingName".to_string(), "s3".to_string().into());
4574                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4575                        out.insert("disableDoubleEncoding".to_string(), true.into());
4576                        out
4577                    })]
4578                )
4579                .build()
4580        );
4581    }
4582
4583    /// fips@us-gov-west-2, bucket is not S3-dns-compatible (subdomains)
4584    #[test]
4585    fn test_165() {
4586        let params = crate::config::endpoint::Params::builder()
4587            .accelerate(false)
4588            .bucket("bucket.with.dots".to_string())
4589            .region("us-gov-west-1".to_string())
4590            .use_dual_stack(false)
4591            .use_fips(true)
4592            .build()
4593            .expect("invalid params");
4594        let resolver = crate::config::endpoint::DefaultResolver::new();
4595        let endpoint = resolver.resolve_endpoint(&params);
4596        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-gov-west-1.amazonaws.com/bucket.with.dots");
4597        assert_eq!(
4598            endpoint,
4599            ::aws_smithy_types::endpoint::Endpoint::builder()
4600                .url("https://s3-fips.us-gov-west-1.amazonaws.com/bucket.with.dots")
4601                .property(
4602                    "authSchemes",
4603                    vec![::aws_smithy_types::Document::from({
4604                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4605                        out.insert("signingName".to_string(), "s3".to_string().into());
4606                        out.insert("signingRegion".to_string(), "us-gov-west-1".to_string().into());
4607                        out.insert("disableDoubleEncoding".to_string(), true.into());
4608                        out.insert("name".to_string(), "sigv4".to_string().into());
4609                        out
4610                    })]
4611                )
4612                .build()
4613        );
4614    }
4615
4616    /// path style + accelerate = error@us-west-2
4617    #[test]
4618    fn test_166() {
4619        let params = crate::config::endpoint::Params::builder()
4620            .accelerate(true)
4621            .bucket("bucket-name".to_string())
4622            .force_path_style(true)
4623            .region("us-west-2".to_string())
4624            .use_dual_stack(false)
4625            .use_fips(false)
4626            .build()
4627            .expect("invalid params");
4628        let resolver = crate::config::endpoint::DefaultResolver::new();
4629        let endpoint = resolver.resolve_endpoint(&params);
4630        let error = endpoint
4631            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@us-west-2]");
4632        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
4633    }
4634
4635    /// path style + dualstack@us-west-2
4636    #[test]
4637    fn test_167() {
4638        let params = crate::config::endpoint::Params::builder()
4639            .accelerate(false)
4640            .bucket("bucket-name".to_string())
4641            .force_path_style(true)
4642            .region("us-west-2".to_string())
4643            .use_dual_stack(true)
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 endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/bucket-name");
4650        assert_eq!(
4651            endpoint,
4652            ::aws_smithy_types::endpoint::Endpoint::builder()
4653                .url("https://s3.dualstack.us-west-2.amazonaws.com/bucket-name")
4654                .property(
4655                    "authSchemes",
4656                    vec![::aws_smithy_types::Document::from({
4657                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4658                        out.insert("name".to_string(), "sigv4".to_string().into());
4659                        out.insert("signingName".to_string(), "s3".to_string().into());
4660                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4661                        out.insert("disableDoubleEncoding".to_string(), true.into());
4662                        out
4663                    })]
4664                )
4665                .build()
4666        );
4667    }
4668
4669    /// path style + arn is error@us-west-2
4670    #[test]
4671    fn test_168() {
4672        let params = crate::config::endpoint::Params::builder()
4673            .accelerate(false)
4674            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
4675            .force_path_style(true)
4676            .region("us-west-2".to_string())
4677            .use_dual_stack(false)
4678            .use_fips(false)
4679            .build()
4680            .expect("invalid params");
4681        let resolver = crate::config::endpoint::DefaultResolver::new();
4682        let endpoint = resolver.resolve_endpoint(&params);
4683        let error =
4684            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@us-west-2]");
4685        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
4686    }
4687
4688    /// 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            .force_path_style(true)
4695            .region("us-west-2".to_string())
4696            .use_dual_stack(false)
4697            .use_fips(false)
4698            .build()
4699            .expect("invalid params");
4700        let resolver = crate::config::endpoint::DefaultResolver::new();
4701        let endpoint = resolver.resolve_endpoint(&params);
4702        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/99a_b");
4703        assert_eq!(
4704            endpoint,
4705            ::aws_smithy_types::endpoint::Endpoint::builder()
4706                .url("https://s3.us-west-2.amazonaws.com/99a_b")
4707                .property(
4708                    "authSchemes",
4709                    vec![::aws_smithy_types::Document::from({
4710                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4711                        out.insert("name".to_string(), "sigv4".to_string().into());
4712                        out.insert("signingName".to_string(), "s3".to_string().into());
4713                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
4714                        out.insert("disableDoubleEncoding".to_string(), true.into());
4715                        out
4716                    })]
4717                )
4718                .build()
4719        );
4720    }
4721
4722    /// no path style + invalid DNS name@us-west-2
4723    #[test]
4724    fn test_170() {
4725        let params = crate::config::endpoint::Params::builder()
4726            .accelerate(false)
4727            .bucket("99a_b".to_string())
4728            .region("us-west-2".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.us-west-2.amazonaws.com/99a_b");
4736        assert_eq!(
4737            endpoint,
4738            ::aws_smithy_types::endpoint::Endpoint::builder()
4739                .url("https://s3.us-west-2.amazonaws.com/99a_b")
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(), "us-west-2".to_string().into());
4747                        out.insert("disableDoubleEncoding".to_string(), true.into());
4748                        out
4749                    })]
4750                )
4751                .build()
4752        );
4753    }
4754
4755    /// vanilla path style@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(false)
4765            .build()
4766            .expect("invalid params");
4767        let resolver = crate::config::endpoint::DefaultResolver::new();
4768        let endpoint = resolver.resolve_endpoint(&params);
4769        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/bucket-name");
4770        assert_eq!(
4771            endpoint,
4772            ::aws_smithy_types::endpoint::Endpoint::builder()
4773                .url("https://s3.cn-north-1.amazonaws.com.cn/bucket-name")
4774                .property(
4775                    "authSchemes",
4776                    vec![::aws_smithy_types::Document::from({
4777                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4778                        out.insert("name".to_string(), "sigv4".to_string().into());
4779                        out.insert("signingName".to_string(), "s3".to_string().into());
4780                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4781                        out.insert("disableDoubleEncoding".to_string(), true.into());
4782                        out
4783                    })]
4784                )
4785                .build()
4786        );
4787    }
4788
4789    /// path style + fips@cn-north-1
4790    #[test]
4791    fn test_172() {
4792        let params = crate::config::endpoint::Params::builder()
4793            .accelerate(false)
4794            .bucket("bucket-name".to_string())
4795            .force_path_style(true)
4796            .region("cn-north-1".to_string())
4797            .use_dual_stack(false)
4798            .use_fips(true)
4799            .build()
4800            .expect("invalid params");
4801        let resolver = crate::config::endpoint::DefaultResolver::new();
4802        let endpoint = resolver.resolve_endpoint(&params);
4803        let error = endpoint.expect_err("expected error: Partition does not support FIPS [path style + fips@cn-north-1]");
4804        assert_eq!(format!("{}", error), "Partition does not support FIPS")
4805    }
4806
4807    /// path style + accelerate = error@cn-north-1
4808    #[test]
4809    fn test_173() {
4810        let params = crate::config::endpoint::Params::builder()
4811            .accelerate(true)
4812            .bucket("bucket-name".to_string())
4813            .force_path_style(true)
4814            .region("cn-north-1".to_string())
4815            .use_dual_stack(false)
4816            .use_fips(false)
4817            .build()
4818            .expect("invalid params");
4819        let resolver = crate::config::endpoint::DefaultResolver::new();
4820        let endpoint = resolver.resolve_endpoint(&params);
4821        let error = endpoint
4822            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@cn-north-1]");
4823        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
4824    }
4825
4826    /// path style + dualstack@cn-north-1
4827    #[test]
4828    fn test_174() {
4829        let params = crate::config::endpoint::Params::builder()
4830            .accelerate(false)
4831            .bucket("bucket-name".to_string())
4832            .force_path_style(true)
4833            .region("cn-north-1".to_string())
4834            .use_dual_stack(true)
4835            .use_fips(false)
4836            .build()
4837            .expect("invalid params");
4838        let resolver = crate::config::endpoint::DefaultResolver::new();
4839        let endpoint = resolver.resolve_endpoint(&params);
4840        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.cn-north-1.amazonaws.com.cn/bucket-name");
4841        assert_eq!(
4842            endpoint,
4843            ::aws_smithy_types::endpoint::Endpoint::builder()
4844                .url("https://s3.dualstack.cn-north-1.amazonaws.com.cn/bucket-name")
4845                .property(
4846                    "authSchemes",
4847                    vec![::aws_smithy_types::Document::from({
4848                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4849                        out.insert("name".to_string(), "sigv4".to_string().into());
4850                        out.insert("signingName".to_string(), "s3".to_string().into());
4851                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4852                        out.insert("disableDoubleEncoding".to_string(), true.into());
4853                        out
4854                    })]
4855                )
4856                .build()
4857        );
4858    }
4859
4860    /// path style + arn is error@cn-north-1
4861    #[test]
4862    fn test_175() {
4863        let params = crate::config::endpoint::Params::builder()
4864            .accelerate(false)
4865            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
4866            .force_path_style(true)
4867            .region("cn-north-1".to_string())
4868            .use_dual_stack(false)
4869            .use_fips(false)
4870            .build()
4871            .expect("invalid params");
4872        let resolver = crate::config::endpoint::DefaultResolver::new();
4873        let endpoint = resolver.resolve_endpoint(&params);
4874        let error =
4875            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@cn-north-1]");
4876        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
4877    }
4878
4879    /// 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            .force_path_style(true)
4886            .region("cn-north-1".to_string())
4887            .use_dual_stack(false)
4888            .use_fips(false)
4889            .build()
4890            .expect("invalid params");
4891        let resolver = crate::config::endpoint::DefaultResolver::new();
4892        let endpoint = resolver.resolve_endpoint(&params);
4893        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/99a_b");
4894        assert_eq!(
4895            endpoint,
4896            ::aws_smithy_types::endpoint::Endpoint::builder()
4897                .url("https://s3.cn-north-1.amazonaws.com.cn/99a_b")
4898                .property(
4899                    "authSchemes",
4900                    vec![::aws_smithy_types::Document::from({
4901                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4902                        out.insert("name".to_string(), "sigv4".to_string().into());
4903                        out.insert("signingName".to_string(), "s3".to_string().into());
4904                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
4905                        out.insert("disableDoubleEncoding".to_string(), true.into());
4906                        out
4907                    })]
4908                )
4909                .build()
4910        );
4911    }
4912
4913    /// no path style + invalid DNS name@cn-north-1
4914    #[test]
4915    fn test_177() {
4916        let params = crate::config::endpoint::Params::builder()
4917            .accelerate(false)
4918            .bucket("99a_b".to_string())
4919            .region("cn-north-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.cn-north-1.amazonaws.com.cn/99a_b");
4927        assert_eq!(
4928            endpoint,
4929            ::aws_smithy_types::endpoint::Endpoint::builder()
4930                .url("https://s3.cn-north-1.amazonaws.com.cn/99a_b")
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(), "cn-north-1".to_string().into());
4938                        out.insert("disableDoubleEncoding".to_string(), true.into());
4939                        out
4940                    })]
4941                )
4942                .build()
4943        );
4944    }
4945
4946    /// vanilla path style@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(false)
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.af-south-1.amazonaws.com/bucket-name");
4961        assert_eq!(
4962            endpoint,
4963            ::aws_smithy_types::endpoint::Endpoint::builder()
4964                .url("https://s3.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("name".to_string(), "sigv4".to_string().into());
4970                        out.insert("signingName".to_string(), "s3".to_string().into());
4971                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
4972                        out.insert("disableDoubleEncoding".to_string(), true.into());
4973                        out
4974                    })]
4975                )
4976                .build()
4977        );
4978    }
4979
4980    /// path style + fips@af-south-1
4981    #[test]
4982    fn test_179() {
4983        let params = crate::config::endpoint::Params::builder()
4984            .accelerate(false)
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(true)
4990            .build()
4991            .expect("invalid params");
4992        let resolver = crate::config::endpoint::DefaultResolver::new();
4993        let endpoint = resolver.resolve_endpoint(&params);
4994        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.af-south-1.amazonaws.com/bucket-name");
4995        assert_eq!(
4996            endpoint,
4997            ::aws_smithy_types::endpoint::Endpoint::builder()
4998                .url("https://s3-fips.af-south-1.amazonaws.com/bucket-name")
4999                .property(
5000                    "authSchemes",
5001                    vec![::aws_smithy_types::Document::from({
5002                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5003                        out.insert("signingName".to_string(), "s3".to_string().into());
5004                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5005                        out.insert("disableDoubleEncoding".to_string(), true.into());
5006                        out.insert("name".to_string(), "sigv4".to_string().into());
5007                        out
5008                    })]
5009                )
5010                .build()
5011        );
5012    }
5013
5014    /// path style + accelerate = error@af-south-1
5015    #[test]
5016    fn test_180() {
5017        let params = crate::config::endpoint::Params::builder()
5018            .accelerate(true)
5019            .bucket("bucket-name".to_string())
5020            .force_path_style(true)
5021            .region("af-south-1".to_string())
5022            .use_dual_stack(false)
5023            .use_fips(false)
5024            .build()
5025            .expect("invalid params");
5026        let resolver = crate::config::endpoint::DefaultResolver::new();
5027        let endpoint = resolver.resolve_endpoint(&params);
5028        let error = endpoint
5029            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@af-south-1]");
5030        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
5031    }
5032
5033    /// path style + dualstack@af-south-1
5034    #[test]
5035    fn test_181() {
5036        let params = crate::config::endpoint::Params::builder()
5037            .accelerate(false)
5038            .bucket("bucket-name".to_string())
5039            .force_path_style(true)
5040            .region("af-south-1".to_string())
5041            .use_dual_stack(true)
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 endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.af-south-1.amazonaws.com/bucket-name");
5048        assert_eq!(
5049            endpoint,
5050            ::aws_smithy_types::endpoint::Endpoint::builder()
5051                .url("https://s3.dualstack.af-south-1.amazonaws.com/bucket-name")
5052                .property(
5053                    "authSchemes",
5054                    vec![::aws_smithy_types::Document::from({
5055                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5056                        out.insert("name".to_string(), "sigv4".to_string().into());
5057                        out.insert("signingName".to_string(), "s3".to_string().into());
5058                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5059                        out.insert("disableDoubleEncoding".to_string(), true.into());
5060                        out
5061                    })]
5062                )
5063                .build()
5064        );
5065    }
5066
5067    /// path style + arn is error@af-south-1
5068    #[test]
5069    fn test_182() {
5070        let params = crate::config::endpoint::Params::builder()
5071            .accelerate(false)
5072            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
5073            .force_path_style(true)
5074            .region("af-south-1".to_string())
5075            .use_dual_stack(false)
5076            .use_fips(false)
5077            .build()
5078            .expect("invalid params");
5079        let resolver = crate::config::endpoint::DefaultResolver::new();
5080        let endpoint = resolver.resolve_endpoint(&params);
5081        let error =
5082            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@af-south-1]");
5083        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
5084    }
5085
5086    /// 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            .force_path_style(true)
5093            .region("af-south-1".to_string())
5094            .use_dual_stack(false)
5095            .use_fips(false)
5096            .build()
5097            .expect("invalid params");
5098        let resolver = crate::config::endpoint::DefaultResolver::new();
5099        let endpoint = resolver.resolve_endpoint(&params);
5100        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/99a_b");
5101        assert_eq!(
5102            endpoint,
5103            ::aws_smithy_types::endpoint::Endpoint::builder()
5104                .url("https://s3.af-south-1.amazonaws.com/99a_b")
5105                .property(
5106                    "authSchemes",
5107                    vec![::aws_smithy_types::Document::from({
5108                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5109                        out.insert("name".to_string(), "sigv4".to_string().into());
5110                        out.insert("signingName".to_string(), "s3".to_string().into());
5111                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5112                        out.insert("disableDoubleEncoding".to_string(), true.into());
5113                        out
5114                    })]
5115                )
5116                .build()
5117        );
5118    }
5119
5120    /// no path style + invalid DNS name@af-south-1
5121    #[test]
5122    fn test_184() {
5123        let params = crate::config::endpoint::Params::builder()
5124            .accelerate(false)
5125            .bucket("99a_b".to_string())
5126            .region("af-south-1".to_string())
5127            .use_dual_stack(false)
5128            .use_fips(false)
5129            .build()
5130            .expect("invalid params");
5131        let resolver = crate::config::endpoint::DefaultResolver::new();
5132        let endpoint = resolver.resolve_endpoint(&params);
5133        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/99a_b");
5134        assert_eq!(
5135            endpoint,
5136            ::aws_smithy_types::endpoint::Endpoint::builder()
5137                .url("https://s3.af-south-1.amazonaws.com/99a_b")
5138                .property(
5139                    "authSchemes",
5140                    vec![::aws_smithy_types::Document::from({
5141                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5142                        out.insert("name".to_string(), "sigv4".to_string().into());
5143                        out.insert("signingName".to_string(), "s3".to_string().into());
5144                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5145                        out.insert("disableDoubleEncoding".to_string(), true.into());
5146                        out
5147                    })]
5148                )
5149                .build()
5150        );
5151    }
5152
5153    /// virtual addressing + private link@us-west-2
5154    #[test]
5155    fn test_185() {
5156        let params = crate::config::endpoint::Params::builder()
5157            .accelerate(false)
5158            .bucket("bucket-name".to_string())
5159            .force_path_style(false)
5160            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5161            .region("us-west-2".to_string())
5162            .use_dual_stack(false)
5163            .use_fips(false)
5164            .build()
5165            .expect("invalid params");
5166        let resolver = crate::config::endpoint::DefaultResolver::new();
5167        let endpoint = resolver.resolve_endpoint(&params);
5168        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
5169        assert_eq!(
5170            endpoint,
5171            ::aws_smithy_types::endpoint::Endpoint::builder()
5172                .url("http://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
5173                .property(
5174                    "authSchemes",
5175                    vec![::aws_smithy_types::Document::from({
5176                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5177                        out.insert("name".to_string(), "sigv4".to_string().into());
5178                        out.insert("signingName".to_string(), "s3".to_string().into());
5179                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5180                        out.insert("disableDoubleEncoding".to_string(), true.into());
5181                        out
5182                    })]
5183                )
5184                .build()
5185        );
5186    }
5187
5188    /// path style + private link@us-west-2
5189    #[test]
5190    fn test_186() {
5191        let params = crate::config::endpoint::Params::builder()
5192            .accelerate(false)
5193            .bucket("bucket-name".to_string())
5194            .force_path_style(true)
5195            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5196            .region("us-west-2".to_string())
5197            .use_dual_stack(false)
5198            .use_fips(false)
5199            .build()
5200            .expect("invalid params");
5201        let resolver = crate::config::endpoint::DefaultResolver::new();
5202        let endpoint = resolver.resolve_endpoint(&params);
5203        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
5204        assert_eq!(
5205            endpoint,
5206            ::aws_smithy_types::endpoint::Endpoint::builder()
5207                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
5208                .property(
5209                    "authSchemes",
5210                    vec![::aws_smithy_types::Document::from({
5211                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5212                        out.insert("name".to_string(), "sigv4".to_string().into());
5213                        out.insert("signingName".to_string(), "s3".to_string().into());
5214                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5215                        out.insert("disableDoubleEncoding".to_string(), true.into());
5216                        out
5217                    })]
5218                )
5219                .build()
5220        );
5221    }
5222
5223    /// SDK::Host + FIPS@us-west-2
5224    #[test]
5225    fn test_187() {
5226        let params = crate::config::endpoint::Params::builder()
5227            .accelerate(false)
5228            .bucket("bucket-name".to_string())
5229            .force_path_style(false)
5230            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5231            .region("us-west-2".to_string())
5232            .use_dual_stack(false)
5233            .use_fips(true)
5234            .build()
5235            .expect("invalid params");
5236        let resolver = crate::config::endpoint::DefaultResolver::new();
5237        let endpoint = resolver.resolve_endpoint(&params);
5238        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [SDK::Host + FIPS@us-west-2]");
5239        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
5240    }
5241
5242    /// SDK::Host + DualStack@us-west-2
5243    #[test]
5244    fn test_188() {
5245        let params = crate::config::endpoint::Params::builder()
5246            .accelerate(false)
5247            .bucket("bucket-name".to_string())
5248            .force_path_style(false)
5249            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5250            .region("us-west-2".to_string())
5251            .use_dual_stack(true)
5252            .use_fips(false)
5253            .build()
5254            .expect("invalid params");
5255        let resolver = crate::config::endpoint::DefaultResolver::new();
5256        let endpoint = resolver.resolve_endpoint(&params);
5257        let error =
5258            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@us-west-2]");
5259        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
5260    }
5261
5262    /// SDK::HOST + accelerate@us-west-2
5263    #[test]
5264    fn test_189() {
5265        let params = crate::config::endpoint::Params::builder()
5266            .accelerate(true)
5267            .bucket("bucket-name".to_string())
5268            .force_path_style(false)
5269            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5270            .region("us-west-2".to_string())
5271            .use_dual_stack(false)
5272            .use_fips(false)
5273            .build()
5274            .expect("invalid params");
5275        let resolver = crate::config::endpoint::DefaultResolver::new();
5276        let endpoint = resolver.resolve_endpoint(&params);
5277        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@us-west-2]");
5278        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
5279    }
5280
5281    /// SDK::Host + access point ARN@us-west-2
5282    #[test]
5283    fn test_190() {
5284        let params = crate::config::endpoint::Params::builder()
5285            .accelerate(false)
5286            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5287            .force_path_style(false)
5288            .endpoint("https://beta.example.com".to_string())
5289            .region("us-west-2".to_string())
5290            .use_dual_stack(false)
5291            .use_fips(false)
5292            .build()
5293            .expect("invalid params");
5294        let resolver = crate::config::endpoint::DefaultResolver::new();
5295        let endpoint = resolver.resolve_endpoint(&params);
5296        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
5297        assert_eq!(
5298            endpoint,
5299            ::aws_smithy_types::endpoint::Endpoint::builder()
5300                .url("https://myendpoint-123456789012.beta.example.com")
5301                .property(
5302                    "authSchemes",
5303                    vec![::aws_smithy_types::Document::from({
5304                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5305                        out.insert("name".to_string(), "sigv4".to_string().into());
5306                        out.insert("signingName".to_string(), "s3".to_string().into());
5307                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5308                        out.insert("disableDoubleEncoding".to_string(), true.into());
5309                        out
5310                    })]
5311                )
5312                .build()
5313        );
5314    }
5315
5316    /// virtual addressing + private link@cn-north-1
5317    #[test]
5318    fn test_191() {
5319        let params = crate::config::endpoint::Params::builder()
5320            .accelerate(false)
5321            .bucket("bucket-name".to_string())
5322            .force_path_style(false)
5323            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5324            .region("cn-north-1".to_string())
5325            .use_dual_stack(false)
5326            .use_fips(false)
5327            .build()
5328            .expect("invalid params");
5329        let resolver = crate::config::endpoint::DefaultResolver::new();
5330        let endpoint = resolver.resolve_endpoint(&params);
5331        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
5332        assert_eq!(
5333            endpoint,
5334            ::aws_smithy_types::endpoint::Endpoint::builder()
5335                .url("https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
5336                .property(
5337                    "authSchemes",
5338                    vec![::aws_smithy_types::Document::from({
5339                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5340                        out.insert("name".to_string(), "sigv4".to_string().into());
5341                        out.insert("signingName".to_string(), "s3".to_string().into());
5342                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5343                        out.insert("disableDoubleEncoding".to_string(), true.into());
5344                        out
5345                    })]
5346                )
5347                .build()
5348        );
5349    }
5350
5351    /// path style + private link@cn-north-1
5352    #[test]
5353    fn test_192() {
5354        let params = crate::config::endpoint::Params::builder()
5355            .accelerate(false)
5356            .bucket("bucket-name".to_string())
5357            .force_path_style(true)
5358            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5359            .region("cn-north-1".to_string())
5360            .use_dual_stack(false)
5361            .use_fips(false)
5362            .build()
5363            .expect("invalid params");
5364        let resolver = crate::config::endpoint::DefaultResolver::new();
5365        let endpoint = resolver.resolve_endpoint(&params);
5366        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
5367        assert_eq!(
5368            endpoint,
5369            ::aws_smithy_types::endpoint::Endpoint::builder()
5370                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
5371                .property(
5372                    "authSchemes",
5373                    vec![::aws_smithy_types::Document::from({
5374                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5375                        out.insert("name".to_string(), "sigv4".to_string().into());
5376                        out.insert("signingName".to_string(), "s3".to_string().into());
5377                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5378                        out.insert("disableDoubleEncoding".to_string(), true.into());
5379                        out
5380                    })]
5381                )
5382                .build()
5383        );
5384    }
5385
5386    /// FIPS@cn-north-1
5387    #[test]
5388    fn test_193() {
5389        let params = crate::config::endpoint::Params::builder()
5390            .accelerate(false)
5391            .bucket("bucket-name".to_string())
5392            .force_path_style(false)
5393            .region("cn-north-1".to_string())
5394            .use_dual_stack(false)
5395            .use_fips(true)
5396            .build()
5397            .expect("invalid params");
5398        let resolver = crate::config::endpoint::DefaultResolver::new();
5399        let endpoint = resolver.resolve_endpoint(&params);
5400        let error = endpoint.expect_err("expected error: Partition does not support FIPS [FIPS@cn-north-1]");
5401        assert_eq!(format!("{}", error), "Partition does not support FIPS")
5402    }
5403
5404    /// SDK::Host + DualStack@cn-north-1
5405    #[test]
5406    fn test_194() {
5407        let params = crate::config::endpoint::Params::builder()
5408            .accelerate(false)
5409            .bucket("bucket-name".to_string())
5410            .force_path_style(false)
5411            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5412            .region("cn-north-1".to_string())
5413            .use_dual_stack(true)
5414            .use_fips(false)
5415            .build()
5416            .expect("invalid params");
5417        let resolver = crate::config::endpoint::DefaultResolver::new();
5418        let endpoint = resolver.resolve_endpoint(&params);
5419        let error =
5420            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@cn-north-1]");
5421        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
5422    }
5423
5424    /// SDK::HOST + accelerate@cn-north-1
5425    #[test]
5426    fn test_195() {
5427        let params = crate::config::endpoint::Params::builder()
5428            .accelerate(true)
5429            .bucket("bucket-name".to_string())
5430            .force_path_style(false)
5431            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5432            .region("cn-north-1".to_string())
5433            .use_dual_stack(false)
5434            .use_fips(false)
5435            .build()
5436            .expect("invalid params");
5437        let resolver = crate::config::endpoint::DefaultResolver::new();
5438        let endpoint = resolver.resolve_endpoint(&params);
5439        let error =
5440            endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@cn-north-1]");
5441        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
5442    }
5443
5444    /// SDK::Host + access point ARN@cn-north-1
5445    #[test]
5446    fn test_196() {
5447        let params = crate::config::endpoint::Params::builder()
5448            .accelerate(false)
5449            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5450            .force_path_style(false)
5451            .endpoint("https://beta.example.com".to_string())
5452            .region("cn-north-1".to_string())
5453            .use_dual_stack(false)
5454            .use_fips(false)
5455            .build()
5456            .expect("invalid params");
5457        let resolver = crate::config::endpoint::DefaultResolver::new();
5458        let endpoint = resolver.resolve_endpoint(&params);
5459        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
5460        assert_eq!(
5461            endpoint,
5462            ::aws_smithy_types::endpoint::Endpoint::builder()
5463                .url("https://myendpoint-123456789012.beta.example.com")
5464                .property(
5465                    "authSchemes",
5466                    vec![::aws_smithy_types::Document::from({
5467                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5468                        out.insert("name".to_string(), "sigv4".to_string().into());
5469                        out.insert("signingName".to_string(), "s3".to_string().into());
5470                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5471                        out.insert("disableDoubleEncoding".to_string(), true.into());
5472                        out
5473                    })]
5474                )
5475                .build()
5476        );
5477    }
5478
5479    /// virtual addressing + private link@af-south-1
5480    #[test]
5481    fn test_197() {
5482        let params = crate::config::endpoint::Params::builder()
5483            .accelerate(false)
5484            .bucket("bucket-name".to_string())
5485            .force_path_style(false)
5486            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5487            .region("af-south-1".to_string())
5488            .use_dual_stack(false)
5489            .use_fips(false)
5490            .build()
5491            .expect("invalid params");
5492        let resolver = crate::config::endpoint::DefaultResolver::new();
5493        let endpoint = resolver.resolve_endpoint(&params);
5494        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
5495        assert_eq!(
5496            endpoint,
5497            ::aws_smithy_types::endpoint::Endpoint::builder()
5498                .url("https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
5499                .property(
5500                    "authSchemes",
5501                    vec![::aws_smithy_types::Document::from({
5502                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5503                        out.insert("name".to_string(), "sigv4".to_string().into());
5504                        out.insert("signingName".to_string(), "s3".to_string().into());
5505                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5506                        out.insert("disableDoubleEncoding".to_string(), true.into());
5507                        out
5508                    })]
5509                )
5510                .build()
5511        );
5512    }
5513
5514    /// path style + private link@af-south-1
5515    #[test]
5516    fn test_198() {
5517        let params = crate::config::endpoint::Params::builder()
5518            .accelerate(false)
5519            .bucket("bucket-name".to_string())
5520            .force_path_style(true)
5521            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5522            .region("af-south-1".to_string())
5523            .use_dual_stack(false)
5524            .use_fips(false)
5525            .build()
5526            .expect("invalid params");
5527        let resolver = crate::config::endpoint::DefaultResolver::new();
5528        let endpoint = resolver.resolve_endpoint(&params);
5529        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
5530        assert_eq!(
5531            endpoint,
5532            ::aws_smithy_types::endpoint::Endpoint::builder()
5533                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
5534                .property(
5535                    "authSchemes",
5536                    vec![::aws_smithy_types::Document::from({
5537                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5538                        out.insert("name".to_string(), "sigv4".to_string().into());
5539                        out.insert("signingName".to_string(), "s3".to_string().into());
5540                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5541                        out.insert("disableDoubleEncoding".to_string(), true.into());
5542                        out
5543                    })]
5544                )
5545                .build()
5546        );
5547    }
5548
5549    /// SDK::Host + FIPS@af-south-1
5550    #[test]
5551    fn test_199() {
5552        let params = crate::config::endpoint::Params::builder()
5553            .accelerate(false)
5554            .bucket("bucket-name".to_string())
5555            .force_path_style(false)
5556            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5557            .region("af-south-1".to_string())
5558            .use_dual_stack(false)
5559            .use_fips(true)
5560            .build()
5561            .expect("invalid params");
5562        let resolver = crate::config::endpoint::DefaultResolver::new();
5563        let endpoint = resolver.resolve_endpoint(&params);
5564        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [SDK::Host + FIPS@af-south-1]");
5565        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
5566    }
5567
5568    /// SDK::Host + DualStack@af-south-1
5569    #[test]
5570    fn test_200() {
5571        let params = crate::config::endpoint::Params::builder()
5572            .accelerate(false)
5573            .bucket("bucket-name".to_string())
5574            .force_path_style(false)
5575            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5576            .region("af-south-1".to_string())
5577            .use_dual_stack(true)
5578            .use_fips(false)
5579            .build()
5580            .expect("invalid params");
5581        let resolver = crate::config::endpoint::DefaultResolver::new();
5582        let endpoint = resolver.resolve_endpoint(&params);
5583        let error =
5584            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@af-south-1]");
5585        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
5586    }
5587
5588    /// SDK::HOST + accelerate@af-south-1
5589    #[test]
5590    fn test_201() {
5591        let params = crate::config::endpoint::Params::builder()
5592            .accelerate(true)
5593            .bucket("bucket-name".to_string())
5594            .force_path_style(false)
5595            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
5596            .region("af-south-1".to_string())
5597            .use_dual_stack(false)
5598            .use_fips(false)
5599            .build()
5600            .expect("invalid params");
5601        let resolver = crate::config::endpoint::DefaultResolver::new();
5602        let endpoint = resolver.resolve_endpoint(&params);
5603        let error =
5604            endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@af-south-1]");
5605        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
5606    }
5607
5608    /// SDK::Host + access point ARN@af-south-1
5609    #[test]
5610    fn test_202() {
5611        let params = crate::config::endpoint::Params::builder()
5612            .accelerate(false)
5613            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5614            .force_path_style(false)
5615            .endpoint("https://beta.example.com".to_string())
5616            .region("af-south-1".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.beta.example.com");
5624        assert_eq!(
5625            endpoint,
5626            ::aws_smithy_types::endpoint::Endpoint::builder()
5627                .url("https://myendpoint-123456789012.beta.example.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(), "af-south-1".to_string().into());
5635                        out.insert("disableDoubleEncoding".to_string(), true.into());
5636                        out
5637                    })]
5638                )
5639                .build()
5640        );
5641    }
5642
5643    /// vanilla access point arn@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(false)
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.us-west-2.amazonaws.com");
5658        assert_eq!(
5659            endpoint,
5660            ::aws_smithy_types::endpoint::Endpoint::builder()
5661                .url("https://myendpoint-123456789012.s3-accesspoint.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 + FIPS@us-west-2
5678    #[test]
5679    fn test_204() {
5680        let params = crate::config::endpoint::Params::builder()
5681            .accelerate(false)
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(true)
5687            .build()
5688            .expect("invalid params");
5689        let resolver = crate::config::endpoint::DefaultResolver::new();
5690        let endpoint = resolver.resolve_endpoint(&params);
5691        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.us-west-2.amazonaws.com");
5692        assert_eq!(
5693            endpoint,
5694            ::aws_smithy_types::endpoint::Endpoint::builder()
5695                .url("https://myendpoint-123456789012.s3-accesspoint-fips.us-west-2.amazonaws.com")
5696                .property(
5697                    "authSchemes",
5698                    vec![::aws_smithy_types::Document::from({
5699                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5700                        out.insert("name".to_string(), "sigv4".to_string().into());
5701                        out.insert("signingName".to_string(), "s3".to_string().into());
5702                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
5703                        out.insert("disableDoubleEncoding".to_string(), true.into());
5704                        out
5705                    })]
5706                )
5707                .build()
5708        );
5709    }
5710
5711    /// access point arn + accelerate = error@us-west-2
5712    #[test]
5713    fn test_205() {
5714        let params = crate::config::endpoint::Params::builder()
5715            .accelerate(true)
5716            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5717            .force_path_style(false)
5718            .region("us-west-2".to_string())
5719            .use_dual_stack(false)
5720            .use_fips(false)
5721            .build()
5722            .expect("invalid params");
5723        let resolver = crate::config::endpoint::DefaultResolver::new();
5724        let endpoint = resolver.resolve_endpoint(&params);
5725        let error =
5726            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@us-west-2]");
5727        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
5728    }
5729
5730    /// access point arn + FIPS + DualStack@us-west-2
5731    #[test]
5732    fn test_206() {
5733        let params = crate::config::endpoint::Params::builder()
5734            .accelerate(false)
5735            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5736            .force_path_style(false)
5737            .region("us-west-2".to_string())
5738            .use_dual_stack(true)
5739            .use_fips(true)
5740            .build()
5741            .expect("invalid params");
5742        let resolver = crate::config::endpoint::DefaultResolver::new();
5743        let endpoint = resolver.resolve_endpoint(&params);
5744        let endpoint =
5745            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com");
5746        assert_eq!(
5747            endpoint,
5748            ::aws_smithy_types::endpoint::Endpoint::builder()
5749                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com")
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(), "us-west-2".to_string().into());
5757                        out.insert("disableDoubleEncoding".to_string(), true.into());
5758                        out
5759                    })]
5760                )
5761                .build()
5762        );
5763    }
5764
5765    /// vanilla access point arn@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(false)
5775            .build()
5776            .expect("invalid params");
5777        let resolver = crate::config::endpoint::DefaultResolver::new();
5778        let endpoint = resolver.resolve_endpoint(&params);
5779        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.cn-north-1.amazonaws.com.cn");
5780        assert_eq!(
5781            endpoint,
5782            ::aws_smithy_types::endpoint::Endpoint::builder()
5783                .url("https://myendpoint-123456789012.s3-accesspoint.cn-north-1.amazonaws.com.cn")
5784                .property(
5785                    "authSchemes",
5786                    vec![::aws_smithy_types::Document::from({
5787                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5788                        out.insert("name".to_string(), "sigv4".to_string().into());
5789                        out.insert("signingName".to_string(), "s3".to_string().into());
5790                        out.insert("signingRegion".to_string(), "cn-north-1".to_string().into());
5791                        out.insert("disableDoubleEncoding".to_string(), true.into());
5792                        out
5793                    })]
5794                )
5795                .build()
5796        );
5797    }
5798
5799    /// access point arn + FIPS@cn-north-1
5800    #[test]
5801    fn test_208() {
5802        let params = crate::config::endpoint::Params::builder()
5803            .accelerate(false)
5804            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5805            .force_path_style(false)
5806            .region("cn-north-1".to_string())
5807            .use_dual_stack(false)
5808            .use_fips(true)
5809            .build()
5810            .expect("invalid params");
5811        let resolver = crate::config::endpoint::DefaultResolver::new();
5812        let endpoint = resolver.resolve_endpoint(&params);
5813        let error = endpoint.expect_err("expected error: Partition does not support FIPS [access point arn + FIPS@cn-north-1]");
5814        assert_eq!(format!("{}", error), "Partition does not support FIPS")
5815    }
5816
5817    /// access point arn + accelerate = error@cn-north-1
5818    #[test]
5819    fn test_209() {
5820        let params = crate::config::endpoint::Params::builder()
5821            .accelerate(true)
5822            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5823            .force_path_style(false)
5824            .region("cn-north-1".to_string())
5825            .use_dual_stack(false)
5826            .use_fips(false)
5827            .build()
5828            .expect("invalid params");
5829        let resolver = crate::config::endpoint::DefaultResolver::new();
5830        let endpoint = resolver.resolve_endpoint(&params);
5831        let error =
5832            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@cn-north-1]");
5833        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
5834    }
5835
5836    /// access point arn + FIPS + DualStack@cn-north-1
5837    #[test]
5838    fn test_210() {
5839        let params = crate::config::endpoint::Params::builder()
5840            .accelerate(false)
5841            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5842            .force_path_style(false)
5843            .region("cn-north-1".to_string())
5844            .use_dual_stack(true)
5845            .use_fips(true)
5846            .build()
5847            .expect("invalid params");
5848        let resolver = crate::config::endpoint::DefaultResolver::new();
5849        let endpoint = resolver.resolve_endpoint(&params);
5850        let error = endpoint.expect_err("expected error: Partition does not support FIPS [access point arn + FIPS + DualStack@cn-north-1]");
5851        assert_eq!(format!("{}", error), "Partition does not support FIPS")
5852    }
5853
5854    /// vanilla access point arn@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(false)
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.af-south-1.amazonaws.com");
5869        assert_eq!(
5870            endpoint,
5871            ::aws_smithy_types::endpoint::Endpoint::builder()
5872                .url("https://myendpoint-123456789012.s3-accesspoint.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 + FIPS@af-south-1
5889    #[test]
5890    fn test_212() {
5891        let params = crate::config::endpoint::Params::builder()
5892            .accelerate(false)
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(true)
5898            .build()
5899            .expect("invalid params");
5900        let resolver = crate::config::endpoint::DefaultResolver::new();
5901        let endpoint = resolver.resolve_endpoint(&params);
5902        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.af-south-1.amazonaws.com");
5903        assert_eq!(
5904            endpoint,
5905            ::aws_smithy_types::endpoint::Endpoint::builder()
5906                .url("https://myendpoint-123456789012.s3-accesspoint-fips.af-south-1.amazonaws.com")
5907                .property(
5908                    "authSchemes",
5909                    vec![::aws_smithy_types::Document::from({
5910                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5911                        out.insert("name".to_string(), "sigv4".to_string().into());
5912                        out.insert("signingName".to_string(), "s3".to_string().into());
5913                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5914                        out.insert("disableDoubleEncoding".to_string(), true.into());
5915                        out
5916                    })]
5917                )
5918                .build()
5919        );
5920    }
5921
5922    /// access point arn + accelerate = error@af-south-1
5923    #[test]
5924    fn test_213() {
5925        let params = crate::config::endpoint::Params::builder()
5926            .accelerate(true)
5927            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5928            .force_path_style(false)
5929            .region("af-south-1".to_string())
5930            .use_dual_stack(false)
5931            .use_fips(false)
5932            .build()
5933            .expect("invalid params");
5934        let resolver = crate::config::endpoint::DefaultResolver::new();
5935        let endpoint = resolver.resolve_endpoint(&params);
5936        let error =
5937            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@af-south-1]");
5938        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
5939    }
5940
5941    /// access point arn + FIPS + DualStack@af-south-1
5942    #[test]
5943    fn test_214() {
5944        let params = crate::config::endpoint::Params::builder()
5945            .accelerate(false)
5946            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5947            .force_path_style(false)
5948            .region("af-south-1".to_string())
5949            .use_dual_stack(true)
5950            .use_fips(true)
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://myendpoint-123456789012.s3-accesspoint-fips.dualstack.af-south-1.amazonaws.com");
5957        assert_eq!(
5958            endpoint,
5959            ::aws_smithy_types::endpoint::Endpoint::builder()
5960                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.af-south-1.amazonaws.com")
5961                .property(
5962                    "authSchemes",
5963                    vec![::aws_smithy_types::Document::from({
5964                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
5965                        out.insert("name".to_string(), "sigv4".to_string().into());
5966                        out.insert("signingName".to_string(), "s3".to_string().into());
5967                        out.insert("signingRegion".to_string(), "af-south-1".to_string().into());
5968                        out.insert("disableDoubleEncoding".to_string(), true.into());
5969                        out
5970                    })]
5971                )
5972                .build()
5973        );
5974    }
5975
5976    /// S3 outposts vanilla test
5977    #[test]
5978    fn test_215() {
5979        let params = crate::config::endpoint::Params::builder()
5980            .region("us-west-2".to_string())
5981            .use_fips(false)
5982            .use_dual_stack(false)
5983            .accelerate(false)
5984            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
5985            .build()
5986            .expect("invalid params");
5987        let resolver = crate::config::endpoint::DefaultResolver::new();
5988        let endpoint = resolver.resolve_endpoint(&params);
5989        let endpoint =
5990            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-west-2.amazonaws.com");
5991        assert_eq!(
5992            endpoint,
5993            ::aws_smithy_types::endpoint::Endpoint::builder()
5994                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-west-2.amazonaws.com")
5995                .property(
5996                    "authSchemes",
5997                    vec![
5998                        ::aws_smithy_types::Document::from({
5999                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6000                            out.insert("name".to_string(), "sigv4a".to_string().into());
6001                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6002                            out.insert(
6003                                "signingRegionSet".to_string(),
6004                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
6005                            );
6006                            out.insert("disableDoubleEncoding".to_string(), true.into());
6007                            out
6008                        }),
6009                        ::aws_smithy_types::Document::from({
6010                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6011                            out.insert("name".to_string(), "sigv4".to_string().into());
6012                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6013                            out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6014                            out.insert("disableDoubleEncoding".to_string(), true.into());
6015                            out
6016                        })
6017                    ]
6018                )
6019                .build()
6020        );
6021    }
6022
6023    /// S3 outposts custom endpoint
6024    #[test]
6025    fn test_216() {
6026        let params = crate::config::endpoint::Params::builder()
6027            .region("us-west-2".to_string())
6028            .use_fips(false)
6029            .use_dual_stack(false)
6030            .accelerate(false)
6031            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6032            .endpoint("https://example.amazonaws.com".to_string())
6033            .build()
6034            .expect("invalid params");
6035        let resolver = crate::config::endpoint::DefaultResolver::new();
6036        let endpoint = resolver.resolve_endpoint(&params);
6037        let endpoint = endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.example.amazonaws.com");
6038        assert_eq!(
6039            endpoint,
6040            ::aws_smithy_types::endpoint::Endpoint::builder()
6041                .url("https://reports-123456789012.op-01234567890123456.example.amazonaws.com")
6042                .property(
6043                    "authSchemes",
6044                    vec![
6045                        ::aws_smithy_types::Document::from({
6046                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6047                            out.insert("name".to_string(), "sigv4a".to_string().into());
6048                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6049                            out.insert(
6050                                "signingRegionSet".to_string(),
6051                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
6052                            );
6053                            out.insert("disableDoubleEncoding".to_string(), true.into());
6054                            out
6055                        }),
6056                        ::aws_smithy_types::Document::from({
6057                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6058                            out.insert("name".to_string(), "sigv4".to_string().into());
6059                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6060                            out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6061                            out.insert("disableDoubleEncoding".to_string(), true.into());
6062                            out
6063                        })
6064                    ]
6065                )
6066                .build()
6067        );
6068    }
6069
6070    /// outposts arn with region mismatch and UseArnRegion=false
6071    #[test]
6072    fn test_217() {
6073        let params = crate::config::endpoint::Params::builder()
6074            .accelerate(false)
6075            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6076            .force_path_style(false)
6077            .use_arn_region(false)
6078            .region("us-west-2".to_string())
6079            .use_dual_stack(false)
6080            .use_fips(false)
6081            .build()
6082            .expect("invalid params");
6083        let resolver = crate::config::endpoint::DefaultResolver::new();
6084        let endpoint = resolver.resolve_endpoint(&params);
6085        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]");
6086        assert_eq!(
6087            format!("{}", error),
6088            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
6089        )
6090    }
6091
6092    /// outposts arn with region mismatch, custom region and UseArnRegion=false
6093    #[test]
6094    fn test_218() {
6095        let params = crate::config::endpoint::Params::builder()
6096            .accelerate(false)
6097            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6098            .endpoint("https://example.com".to_string())
6099            .force_path_style(false)
6100            .use_arn_region(false)
6101            .region("us-west-2".to_string())
6102            .use_dual_stack(false)
6103            .use_fips(false)
6104            .build()
6105            .expect("invalid params");
6106        let resolver = crate::config::endpoint::DefaultResolver::new();
6107        let endpoint = resolver.resolve_endpoint(&params);
6108        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]");
6109        assert_eq!(
6110            format!("{}", error),
6111            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
6112        )
6113    }
6114
6115    /// outposts arn with region mismatch and UseArnRegion=true
6116    #[test]
6117    fn test_219() {
6118        let params = crate::config::endpoint::Params::builder()
6119            .accelerate(false)
6120            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6121            .force_path_style(false)
6122            .use_arn_region(true)
6123            .region("us-west-2".to_string())
6124            .use_dual_stack(false)
6125            .use_fips(false)
6126            .build()
6127            .expect("invalid params");
6128        let resolver = crate::config::endpoint::DefaultResolver::new();
6129        let endpoint = resolver.resolve_endpoint(&params);
6130        let endpoint =
6131            endpoint.expect("Expected valid endpoint: https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
6132        assert_eq!(
6133            endpoint,
6134            ::aws_smithy_types::endpoint::Endpoint::builder()
6135                .url("https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
6136                .property(
6137                    "authSchemes",
6138                    vec![
6139                        ::aws_smithy_types::Document::from({
6140                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6141                            out.insert("name".to_string(), "sigv4a".to_string().into());
6142                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6143                            out.insert(
6144                                "signingRegionSet".to_string(),
6145                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
6146                            );
6147                            out.insert("disableDoubleEncoding".to_string(), true.into());
6148                            out
6149                        }),
6150                        ::aws_smithy_types::Document::from({
6151                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6152                            out.insert("name".to_string(), "sigv4".to_string().into());
6153                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6154                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6155                            out.insert("disableDoubleEncoding".to_string(), true.into());
6156                            out
6157                        })
6158                    ]
6159                )
6160                .build()
6161        );
6162    }
6163
6164    /// outposts arn with region mismatch and UseArnRegion unset
6165    #[test]
6166    fn test_220() {
6167        let params = crate::config::endpoint::Params::builder()
6168            .accelerate(false)
6169            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6170            .force_path_style(false)
6171            .region("us-west-2".to_string())
6172            .use_dual_stack(false)
6173            .use_fips(false)
6174            .build()
6175            .expect("invalid params");
6176        let resolver = crate::config::endpoint::DefaultResolver::new();
6177        let endpoint = resolver.resolve_endpoint(&params);
6178        let endpoint =
6179            endpoint.expect("Expected valid endpoint: https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
6180        assert_eq!(
6181            endpoint,
6182            ::aws_smithy_types::endpoint::Endpoint::builder()
6183                .url("https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
6184                .property(
6185                    "authSchemes",
6186                    vec![
6187                        ::aws_smithy_types::Document::from({
6188                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6189                            out.insert("name".to_string(), "sigv4a".to_string().into());
6190                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6191                            out.insert(
6192                                "signingRegionSet".to_string(),
6193                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
6194                            );
6195                            out.insert("disableDoubleEncoding".to_string(), true.into());
6196                            out
6197                        }),
6198                        ::aws_smithy_types::Document::from({
6199                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6200                            out.insert("name".to_string(), "sigv4".to_string().into());
6201                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6202                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6203                            out.insert("disableDoubleEncoding".to_string(), true.into());
6204                            out
6205                        })
6206                    ]
6207                )
6208                .build()
6209        );
6210    }
6211
6212    /// outposts arn with partition mismatch and UseArnRegion=true
6213    #[test]
6214    fn test_221() {
6215        let params = crate::config::endpoint::Params::builder()
6216            .accelerate(false)
6217            .bucket("arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
6218            .force_path_style(false)
6219            .use_arn_region(true)
6220            .region("us-west-2".to_string())
6221            .use_dual_stack(false)
6222            .use_fips(false)
6223            .build()
6224            .expect("invalid params");
6225        let resolver = crate::config::endpoint::DefaultResolver::new();
6226        let endpoint = resolver.resolve_endpoint(&params);
6227        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]");
6228        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`")
6229    }
6230
6231    /// ARN with UseGlobalEndpoint and use-east-1 region uses the regional endpoint
6232    #[test]
6233    fn test_222() {
6234        let params = crate::config::endpoint::Params::builder()
6235            .region("us-east-1".to_string())
6236            .use_global_endpoint(true)
6237            .use_fips(false)
6238            .use_dual_stack(false)
6239            .accelerate(false)
6240            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6241            .build()
6242            .expect("invalid params");
6243        let resolver = crate::config::endpoint::DefaultResolver::new();
6244        let endpoint = resolver.resolve_endpoint(&params);
6245        let endpoint =
6246            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
6247        assert_eq!(
6248            endpoint,
6249            ::aws_smithy_types::endpoint::Endpoint::builder()
6250                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
6251                .property(
6252                    "authSchemes",
6253                    vec![
6254                        ::aws_smithy_types::Document::from({
6255                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6256                            out.insert("name".to_string(), "sigv4a".to_string().into());
6257                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6258                            out.insert(
6259                                "signingRegionSet".to_string(),
6260                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
6261                            );
6262                            out.insert("disableDoubleEncoding".to_string(), true.into());
6263                            out
6264                        }),
6265                        ::aws_smithy_types::Document::from({
6266                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6267                            out.insert("name".to_string(), "sigv4".to_string().into());
6268                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
6269                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6270                            out.insert("disableDoubleEncoding".to_string(), true.into());
6271                            out
6272                        })
6273                    ]
6274                )
6275                .build()
6276        );
6277    }
6278
6279    /// S3 outposts does not support dualstack
6280    #[test]
6281    fn test_223() {
6282        let params = crate::config::endpoint::Params::builder()
6283            .region("us-east-1".to_string())
6284            .use_fips(false)
6285            .use_dual_stack(true)
6286            .accelerate(false)
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 Dual-stack [S3 outposts does not support dualstack]");
6293        assert_eq!(format!("{}", error), "S3 Outposts does not support Dual-stack")
6294    }
6295
6296    /// S3 outposts does not support fips
6297    #[test]
6298    fn test_224() {
6299        let params = crate::config::endpoint::Params::builder()
6300            .region("us-east-1".to_string())
6301            .use_fips(true)
6302            .use_dual_stack(false)
6303            .accelerate(false)
6304            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".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 = endpoint.expect_err("expected error: S3 Outposts does not support FIPS [S3 outposts does not support fips]");
6310        assert_eq!(format!("{}", error), "S3 Outposts does not support FIPS")
6311    }
6312
6313    /// S3 outposts does not support accelerate
6314    #[test]
6315    fn test_225() {
6316        let params = crate::config::endpoint::Params::builder()
6317            .region("us-east-1".to_string())
6318            .use_fips(false)
6319            .use_dual_stack(false)
6320            .accelerate(true)
6321            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
6322            .build()
6323            .expect("invalid params");
6324        let resolver = crate::config::endpoint::DefaultResolver::new();
6325        let endpoint = resolver.resolve_endpoint(&params);
6326        let error = endpoint.expect_err("expected error: S3 Outposts does not support S3 Accelerate [S3 outposts does not support accelerate]");
6327        assert_eq!(format!("{}", error), "S3 Outposts does not support S3 Accelerate")
6328    }
6329
6330    /// validates against subresource
6331    #[test]
6332    fn test_226() {
6333        let params = crate::config::endpoint::Params::builder()
6334            .region("us-west-2".to_string())
6335            .use_fips(false)
6336            .use_dual_stack(false)
6337            .accelerate(false)
6338            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:mybucket:object:foo".to_string())
6339            .build()
6340            .expect("invalid params");
6341        let resolver = crate::config::endpoint::DefaultResolver::new();
6342        let endpoint = resolver.resolve_endpoint(&params);
6343        let error =
6344            endpoint.expect_err("expected error: Invalid Arn: Outpost Access Point ARN contains sub resources [validates against subresource]");
6345        assert_eq!(format!("{}", error), "Invalid Arn: Outpost Access Point ARN contains sub resources")
6346    }
6347
6348    /// object lambda @us-east-1
6349    #[test]
6350    fn test_227() {
6351        let params = crate::config::endpoint::Params::builder()
6352            .region("us-east-1".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-east-1: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-east-1.amazonaws.com");
6363        assert_eq!(
6364            endpoint,
6365            ::aws_smithy_types::endpoint::Endpoint::builder()
6366                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.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-east-1".to_string().into());
6374                        out.insert("disableDoubleEncoding".to_string(), true.into());
6375                        out
6376                    })]
6377                )
6378                .build()
6379        );
6380    }
6381
6382    /// object lambda @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, colon resource deliminator @us-west-2
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(false)
6425            .bucket("arn:aws:s3-object-lambda:us-west-2: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-west-2.amazonaws.com");
6431        assert_eq!(
6432            endpoint,
6433            ::aws_smithy_types::endpoint::Endpoint::builder()
6434                .url("https://mybanner-123456789012.s3-object-lambda.us-west-2.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-west-2".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 us-west-2, useArnRegion=true
6451    #[test]
6452    fn test_230() {
6453        let params = crate::config::endpoint::Params::builder()
6454            .region("us-west-2".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=true
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(true)
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 endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
6499        assert_eq!(
6500            endpoint,
6501            ::aws_smithy_types::endpoint::Endpoint::builder()
6502                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
6503                .property(
6504                    "authSchemes",
6505                    vec![::aws_smithy_types::Document::from({
6506                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6507                        out.insert("name".to_string(), "sigv4".to_string().into());
6508                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6509                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6510                        out.insert("disableDoubleEncoding".to_string(), true.into());
6511                        out
6512                    })]
6513                )
6514                .build()
6515        );
6516    }
6517
6518    /// object lambda @us-east-1, client region s3-external-1, useArnRegion=false
6519    #[test]
6520    fn test_232() {
6521        let params = crate::config::endpoint::Params::builder()
6522            .region("s3-external-1".to_string())
6523            .use_fips(false)
6524            .use_dual_stack(false)
6525            .accelerate(false)
6526            .use_arn_region(false)
6527            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6528            .build()
6529            .expect("invalid params");
6530        let resolver = crate::config::endpoint::DefaultResolver::new();
6531        let endpoint = resolver.resolve_endpoint(&params);
6532        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]");
6533        assert_eq!(
6534            format!("{}", error),
6535            "Invalid configuration: region from ARN `us-east-1` does not match client region `s3-external-1` and UseArnRegion is `false`"
6536        )
6537    }
6538
6539    /// object lambda @us-east-1, client region aws-global, useArnRegion=true
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(true)
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 endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
6554        assert_eq!(
6555            endpoint,
6556            ::aws_smithy_types::endpoint::Endpoint::builder()
6557                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
6558                .property(
6559                    "authSchemes",
6560                    vec![::aws_smithy_types::Document::from({
6561                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6562                        out.insert("name".to_string(), "sigv4".to_string().into());
6563                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6564                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
6565                        out.insert("disableDoubleEncoding".to_string(), true.into());
6566                        out
6567                    })]
6568                )
6569                .build()
6570        );
6571    }
6572
6573    /// object lambda @us-east-1, client region aws-global, useArnRegion=false
6574    #[test]
6575    fn test_234() {
6576        let params = crate::config::endpoint::Params::builder()
6577            .region("aws-global".to_string())
6578            .use_fips(false)
6579            .use_dual_stack(false)
6580            .accelerate(false)
6581            .use_arn_region(false)
6582            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6583            .build()
6584            .expect("invalid params");
6585        let resolver = crate::config::endpoint::DefaultResolver::new();
6586        let endpoint = resolver.resolve_endpoint(&params);
6587        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]");
6588        assert_eq!(
6589            format!("{}", error),
6590            "Invalid configuration: region from ARN `us-east-1` does not match client region `aws-global` and UseArnRegion is `false`"
6591        )
6592    }
6593
6594    /// object lambda @cn-north-1, client region us-west-2 (cross partition), useArnRegion=true
6595    #[test]
6596    fn test_235() {
6597        let params = crate::config::endpoint::Params::builder()
6598            .region("aws-global".to_string())
6599            .use_fips(false)
6600            .use_dual_stack(false)
6601            .accelerate(false)
6602            .use_arn_region(true)
6603            .bucket("arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner".to_string())
6604            .build()
6605            .expect("invalid params");
6606        let resolver = crate::config::endpoint::DefaultResolver::new();
6607        let endpoint = resolver.resolve_endpoint(&params);
6608        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]");
6609        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`")
6610    }
6611
6612    /// object lambda with dualstack
6613    #[test]
6614    fn test_236() {
6615        let params = crate::config::endpoint::Params::builder()
6616            .region("us-west-2".to_string())
6617            .use_fips(false)
6618            .use_dual_stack(true)
6619            .accelerate(false)
6620            .use_arn_region(false)
6621            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
6622            .build()
6623            .expect("invalid params");
6624        let resolver = crate::config::endpoint::DefaultResolver::new();
6625        let endpoint = resolver.resolve_endpoint(&params);
6626        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support Dual-stack [object lambda with dualstack]");
6627        assert_eq!(format!("{}", error), "S3 Object Lambda does not support Dual-stack")
6628    }
6629
6630    /// object lambda @us-gov-east-1
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(false)
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.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.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 @us-gov-east-1, with fips
6665    #[test]
6666    fn test_238() {
6667        let params = crate::config::endpoint::Params::builder()
6668            .region("us-gov-east-1".to_string())
6669            .use_fips(true)
6670            .use_dual_stack(false)
6671            .accelerate(false)
6672            .use_arn_region(false)
6673            .bucket("arn:aws-us-gov:s3-object-lambda:us-gov-east-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 endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda-fips.us-gov-east-1.amazonaws.com");
6679        assert_eq!(
6680            endpoint,
6681            ::aws_smithy_types::endpoint::Endpoint::builder()
6682                .url("https://mybanner-123456789012.s3-object-lambda-fips.us-gov-east-1.amazonaws.com")
6683                .property(
6684                    "authSchemes",
6685                    vec![::aws_smithy_types::Document::from({
6686                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6687                        out.insert("name".to_string(), "sigv4".to_string().into());
6688                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6689                        out.insert("signingRegion".to_string(), "us-gov-east-1".to_string().into());
6690                        out.insert("disableDoubleEncoding".to_string(), true.into());
6691                        out
6692                    })]
6693                )
6694                .build()
6695        );
6696    }
6697
6698    /// object lambda @cn-north-1, with fips
6699    #[test]
6700    fn test_239() {
6701        let params = crate::config::endpoint::Params::builder()
6702            .region("cn-north-1".to_string())
6703            .use_fips(true)
6704            .use_dual_stack(false)
6705            .accelerate(false)
6706            .use_arn_region(false)
6707            .bucket("arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner".to_string())
6708            .build()
6709            .expect("invalid params");
6710        let resolver = crate::config::endpoint::DefaultResolver::new();
6711        let endpoint = resolver.resolve_endpoint(&params);
6712        let error = endpoint.expect_err("expected error: Partition does not support FIPS [object lambda @cn-north-1, with fips]");
6713        assert_eq!(format!("{}", error), "Partition does not support FIPS")
6714    }
6715
6716    /// object lambda with accelerate
6717    #[test]
6718    fn test_240() {
6719        let params = crate::config::endpoint::Params::builder()
6720            .region("us-west-2".to_string())
6721            .use_fips(false)
6722            .use_dual_stack(false)
6723            .accelerate(true)
6724            .use_arn_region(false)
6725            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
6726            .build()
6727            .expect("invalid params");
6728        let resolver = crate::config::endpoint::DefaultResolver::new();
6729        let endpoint = resolver.resolve_endpoint(&params);
6730        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support S3 Accelerate [object lambda with accelerate]");
6731        assert_eq!(format!("{}", error), "S3 Object Lambda does not support S3 Accelerate")
6732    }
6733
6734    /// object lambda with invalid arn - bad service and someresource
6735    #[test]
6736    fn test_241() {
6737        let params = crate::config::endpoint::Params::builder()
6738            .region("us-west-2".to_string())
6739            .use_fips(false)
6740            .use_dual_stack(false)
6741            .accelerate(false)
6742            .use_arn_region(false)
6743            .bucket("arn:aws:sqs:us-west-2:123456789012:someresource".to_string())
6744            .build()
6745            .expect("invalid params");
6746        let resolver = crate::config::endpoint::DefaultResolver::new();
6747        let endpoint = resolver.resolve_endpoint(&params);
6748        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]");
6749        assert_eq!(
6750            format!("{}", error),
6751            "Invalid ARN: Unrecognized format: arn:aws:sqs:us-west-2:123456789012:someresource (type: someresource)"
6752        )
6753    }
6754
6755    /// object lambda with invalid arn - invalid resource
6756    #[test]
6757    fn test_242() {
6758        let params = crate::config::endpoint::Params::builder()
6759            .region("us-west-2".to_string())
6760            .use_fips(false)
6761            .use_dual_stack(false)
6762            .accelerate(false)
6763            .use_arn_region(false)
6764            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:bucket_name:mybucket".to_string())
6765            .build()
6766            .expect("invalid params");
6767        let resolver = crate::config::endpoint::DefaultResolver::new();
6768        let endpoint = resolver.resolve_endpoint(&params);
6769        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]");
6770        assert_eq!(
6771            format!("{}", error),
6772            "Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `bucket_name`"
6773        )
6774    }
6775
6776    /// object lambda with invalid arn - missing region
6777    #[test]
6778    fn test_243() {
6779        let params = crate::config::endpoint::Params::builder()
6780            .region("us-west-2".to_string())
6781            .use_fips(false)
6782            .use_dual_stack(false)
6783            .accelerate(false)
6784            .use_arn_region(false)
6785            .bucket("arn:aws:s3-object-lambda::123456789012:accesspoint/mybanner".to_string())
6786            .build()
6787            .expect("invalid params");
6788        let resolver = crate::config::endpoint::DefaultResolver::new();
6789        let endpoint = resolver.resolve_endpoint(&params);
6790        let error =
6791            endpoint.expect_err("expected error: Invalid ARN: bucket ARN is missing a region [object lambda with invalid arn - missing region]");
6792        assert_eq!(format!("{}", error), "Invalid ARN: bucket ARN is missing a region")
6793    }
6794
6795    /// object lambda with invalid arn - missing account-id
6796    #[test]
6797    fn test_244() {
6798        let params = crate::config::endpoint::Params::builder()
6799            .region("us-west-2".to_string())
6800            .use_fips(false)
6801            .use_dual_stack(false)
6802            .accelerate(false)
6803            .use_arn_region(true)
6804            .bucket("arn:aws:s3-object-lambda:us-west-2::accesspoint/mybanner".to_string())
6805            .build()
6806            .expect("invalid params");
6807        let resolver = crate::config::endpoint::DefaultResolver::new();
6808        let endpoint = resolver.resolve_endpoint(&params);
6809        let error = endpoint.expect_err("expected error: Invalid ARN: Missing account id [object lambda with invalid arn - missing account-id]");
6810        assert_eq!(format!("{}", error), "Invalid ARN: Missing account id")
6811    }
6812
6813    /// object lambda with invalid arn - account id contains invalid characters
6814    #[test]
6815    fn test_245() {
6816        let params = crate::config::endpoint::Params::builder()
6817            .region("us-west-2".to_string())
6818            .use_fips(false)
6819            .use_dual_stack(false)
6820            .accelerate(false)
6821            .use_arn_region(true)
6822            .bucket("arn:aws:s3-object-lambda:us-west-2:123.45678.9012:accesspoint:mybucket".to_string())
6823            .build()
6824            .expect("invalid params");
6825        let resolver = crate::config::endpoint::DefaultResolver::new();
6826        let endpoint = resolver.resolve_endpoint(&params);
6827        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]");
6828        assert_eq!(
6829            format!("{}", error),
6830            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123.45678.9012`"
6831        )
6832    }
6833
6834    /// object lambda with invalid arn - missing access point name
6835    #[test]
6836    fn test_246() {
6837        let params = crate::config::endpoint::Params::builder()
6838            .region("us-west-2".to_string())
6839            .use_fips(false)
6840            .use_dual_stack(false)
6841            .accelerate(false)
6842            .use_arn_region(true)
6843            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint".to_string())
6844            .build()
6845            .expect("invalid params");
6846        let resolver = crate::config::endpoint::DefaultResolver::new();
6847        let endpoint = resolver.resolve_endpoint(&params);
6848        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]");
6849        assert_eq!(
6850            format!("{}", error),
6851            "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided"
6852        )
6853    }
6854
6855    /// object lambda with invalid arn - access point name contains invalid character: *
6856    #[test]
6857    fn test_247() {
6858        let params = crate::config::endpoint::Params::builder()
6859            .region("us-west-2".to_string())
6860            .use_fips(false)
6861            .use_dual_stack(false)
6862            .accelerate(false)
6863            .use_arn_region(true)
6864            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:*".to_string())
6865            .build()
6866            .expect("invalid params");
6867        let resolver = crate::config::endpoint::DefaultResolver::new();
6868        let endpoint = resolver.resolve_endpoint(&params);
6869        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: *]");
6870        assert_eq!(
6871            format!("{}", error),
6872            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `*`"
6873        )
6874    }
6875
6876    /// object lambda with invalid arn - access point name contains invalid character: .
6877    #[test]
6878    fn test_248() {
6879        let params = crate::config::endpoint::Params::builder()
6880            .region("us-west-2".to_string())
6881            .use_fips(false)
6882            .use_dual_stack(false)
6883            .accelerate(false)
6884            .use_arn_region(true)
6885            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:my.bucket".to_string())
6886            .build()
6887            .expect("invalid params");
6888        let resolver = crate::config::endpoint::DefaultResolver::new();
6889        let endpoint = resolver.resolve_endpoint(&params);
6890        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: .]");
6891        assert_eq!(
6892            format!("{}", error),
6893            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `my.bucket`"
6894        )
6895    }
6896
6897    /// object lambda with invalid arn - access point name contains sub resources
6898    #[test]
6899    fn test_249() {
6900        let params = crate::config::endpoint::Params::builder()
6901            .region("us-west-2".to_string())
6902            .use_fips(false)
6903            .use_dual_stack(false)
6904            .accelerate(false)
6905            .use_arn_region(true)
6906            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:mybucket:object:foo".to_string())
6907            .build()
6908            .expect("invalid params");
6909        let resolver = crate::config::endpoint::DefaultResolver::new();
6910        let endpoint = resolver.resolve_endpoint(&params);
6911        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]");
6912        assert_eq!(
6913            format!("{}", error),
6914            "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`."
6915        )
6916    }
6917
6918    /// object lambda with custom endpoint
6919    #[test]
6920    fn test_250() {
6921        let params = crate::config::endpoint::Params::builder()
6922            .region("us-west-2".to_string())
6923            .use_fips(false)
6924            .use_dual_stack(false)
6925            .accelerate(false)
6926            .use_arn_region(false)
6927            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
6928            .endpoint("https://my-endpoint.com".to_string())
6929            .build()
6930            .expect("invalid params");
6931        let resolver = crate::config::endpoint::DefaultResolver::new();
6932        let endpoint = resolver.resolve_endpoint(&params);
6933        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.my-endpoint.com");
6934        assert_eq!(
6935            endpoint,
6936            ::aws_smithy_types::endpoint::Endpoint::builder()
6937                .url("https://mybanner-123456789012.my-endpoint.com")
6938                .property(
6939                    "authSchemes",
6940                    vec![::aws_smithy_types::Document::from({
6941                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
6942                        out.insert("name".to_string(), "sigv4".to_string().into());
6943                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
6944                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
6945                        out.insert("disableDoubleEncoding".to_string(), true.into());
6946                        out
6947                    })]
6948                )
6949                .build()
6950        );
6951    }
6952
6953    /// object lambda arn with region mismatch and UseArnRegion=false
6954    #[test]
6955    fn test_251() {
6956        let params = crate::config::endpoint::Params::builder()
6957            .accelerate(false)
6958            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6959            .force_path_style(false)
6960            .use_arn_region(false)
6961            .region("us-west-2".to_string())
6962            .use_dual_stack(false)
6963            .use_fips(false)
6964            .build()
6965            .expect("invalid params");
6966        let resolver = crate::config::endpoint::DefaultResolver::new();
6967        let endpoint = resolver.resolve_endpoint(&params);
6968        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]");
6969        assert_eq!(
6970            format!("{}", error),
6971            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
6972        )
6973    }
6974
6975    /// WriteGetObjectResponse @ us-west-2
6976    #[test]
6977    fn test_252() {
6978        let params = crate::config::endpoint::Params::builder()
6979            .accelerate(false)
6980            .use_object_lambda_endpoint(true)
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://s3-object-lambda.us-west-2.amazonaws.com");
6989        assert_eq!(
6990            endpoint,
6991            ::aws_smithy_types::endpoint::Endpoint::builder()
6992                .url("https://s3-object-lambda.us-west-2.amazonaws.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 with custom endpoint
7009    #[test]
7010    fn test_253() {
7011        let params = crate::config::endpoint::Params::builder()
7012            .accelerate(false)
7013            .use_object_lambda_endpoint(true)
7014            .endpoint("https://my-endpoint.com".to_string())
7015            .region("us-west-2".to_string())
7016            .use_dual_stack(false)
7017            .use_fips(false)
7018            .build()
7019            .expect("invalid params");
7020        let resolver = crate::config::endpoint::DefaultResolver::new();
7021        let endpoint = resolver.resolve_endpoint(&params);
7022        let endpoint = endpoint.expect("Expected valid endpoint: https://my-endpoint.com");
7023        assert_eq!(
7024            endpoint,
7025            ::aws_smithy_types::endpoint::Endpoint::builder()
7026                .url("https://my-endpoint.com")
7027                .property(
7028                    "authSchemes",
7029                    vec![::aws_smithy_types::Document::from({
7030                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7031                        out.insert("name".to_string(), "sigv4".to_string().into());
7032                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7033                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7034                        out.insert("disableDoubleEncoding".to_string(), true.into());
7035                        out
7036                    })]
7037                )
7038                .build()
7039        );
7040    }
7041
7042    /// WriteGetObjectResponse @ us-east-1
7043    #[test]
7044    fn test_254() {
7045        let params = crate::config::endpoint::Params::builder()
7046            .accelerate(false)
7047            .use_object_lambda_endpoint(true)
7048            .region("us-east-1".to_string())
7049            .use_dual_stack(false)
7050            .use_fips(false)
7051            .build()
7052            .expect("invalid params");
7053        let resolver = crate::config::endpoint::DefaultResolver::new();
7054        let endpoint = resolver.resolve_endpoint(&params);
7055        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-east-1.amazonaws.com");
7056        assert_eq!(
7057            endpoint,
7058            ::aws_smithy_types::endpoint::Endpoint::builder()
7059                .url("https://s3-object-lambda.us-east-1.amazonaws.com")
7060                .property(
7061                    "authSchemes",
7062                    vec![::aws_smithy_types::Document::from({
7063                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7064                        out.insert("name".to_string(), "sigv4".to_string().into());
7065                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7066                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7067                        out.insert("disableDoubleEncoding".to_string(), true.into());
7068                        out
7069                    })]
7070                )
7071                .build()
7072        );
7073    }
7074
7075    /// WriteGetObjectResponse with fips
7076    #[test]
7077    fn test_255() {
7078        let params = crate::config::endpoint::Params::builder()
7079            .accelerate(false)
7080            .use_object_lambda_endpoint(true)
7081            .region("us-east-1".to_string())
7082            .use_dual_stack(false)
7083            .use_fips(true)
7084            .build()
7085            .expect("invalid params");
7086        let resolver = crate::config::endpoint::DefaultResolver::new();
7087        let endpoint = resolver.resolve_endpoint(&params);
7088        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda-fips.us-east-1.amazonaws.com");
7089        assert_eq!(
7090            endpoint,
7091            ::aws_smithy_types::endpoint::Endpoint::builder()
7092                .url("https://s3-object-lambda-fips.us-east-1.amazonaws.com")
7093                .property(
7094                    "authSchemes",
7095                    vec![::aws_smithy_types::Document::from({
7096                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7097                        out.insert("name".to_string(), "sigv4".to_string().into());
7098                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7099                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7100                        out.insert("disableDoubleEncoding".to_string(), true.into());
7101                        out
7102                    })]
7103                )
7104                .build()
7105        );
7106    }
7107
7108    /// WriteGetObjectResponse with dualstack
7109    #[test]
7110    fn test_256() {
7111        let params = crate::config::endpoint::Params::builder()
7112            .accelerate(false)
7113            .use_object_lambda_endpoint(true)
7114            .region("us-east-1".to_string())
7115            .use_dual_stack(true)
7116            .use_fips(false)
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: S3 Object Lambda does not support Dual-stack [WriteGetObjectResponse with dualstack]");
7122        assert_eq!(format!("{}", error), "S3 Object Lambda does not support Dual-stack")
7123    }
7124
7125    /// WriteGetObjectResponse with accelerate
7126    #[test]
7127    fn test_257() {
7128        let params = crate::config::endpoint::Params::builder()
7129            .accelerate(true)
7130            .use_object_lambda_endpoint(true)
7131            .region("us-east-1".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 = endpoint.expect_err("expected error: S3 Object Lambda does not support S3 Accelerate [WriteGetObjectResponse with accelerate]");
7139        assert_eq!(format!("{}", error), "S3 Object Lambda does not support S3 Accelerate")
7140    }
7141
7142    /// WriteGetObjectResponse with fips in CN
7143    #[test]
7144    fn test_258() {
7145        let params = crate::config::endpoint::Params::builder()
7146            .accelerate(false)
7147            .region("cn-north-1".to_string())
7148            .use_object_lambda_endpoint(true)
7149            .use_dual_stack(false)
7150            .use_fips(true)
7151            .build()
7152            .expect("invalid params");
7153        let resolver = crate::config::endpoint::DefaultResolver::new();
7154        let endpoint = resolver.resolve_endpoint(&params);
7155        let error = endpoint.expect_err("expected error: Partition does not support FIPS [WriteGetObjectResponse with fips in CN]");
7156        assert_eq!(format!("{}", error), "Partition does not support FIPS")
7157    }
7158
7159    /// WriteGetObjectResponse with invalid partition
7160    #[test]
7161    fn test_259() {
7162        let params = crate::config::endpoint::Params::builder()
7163            .accelerate(false)
7164            .use_object_lambda_endpoint(true)
7165            .region("not a valid DNS name".to_string())
7166            .use_dual_stack(false)
7167            .use_fips(false)
7168            .build()
7169            .expect("invalid params");
7170        let resolver = crate::config::endpoint::DefaultResolver::new();
7171        let endpoint = resolver.resolve_endpoint(&params);
7172        let error =
7173            endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [WriteGetObjectResponse with invalid partition]");
7174        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
7175    }
7176
7177    /// WriteGetObjectResponse with an unknown partition
7178    #[test]
7179    fn test_260() {
7180        let params = crate::config::endpoint::Params::builder()
7181            .accelerate(false)
7182            .use_object_lambda_endpoint(true)
7183            .region("us-east.special".to_string())
7184            .use_dual_stack(false)
7185            .use_fips(false)
7186            .build()
7187            .expect("invalid params");
7188        let resolver = crate::config::endpoint::DefaultResolver::new();
7189        let endpoint = resolver.resolve_endpoint(&params);
7190        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-east.special.amazonaws.com");
7191        assert_eq!(
7192            endpoint,
7193            ::aws_smithy_types::endpoint::Endpoint::builder()
7194                .url("https://s3-object-lambda.us-east.special.amazonaws.com")
7195                .property(
7196                    "authSchemes",
7197                    vec![::aws_smithy_types::Document::from({
7198                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7199                        out.insert("name".to_string(), "sigv4".to_string().into());
7200                        out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
7201                        out.insert("disableDoubleEncoding".to_string(), true.into());
7202                        out.insert("signingRegion".to_string(), "us-east.special".to_string().into());
7203                        out
7204                    })]
7205                )
7206                .build()
7207        );
7208    }
7209
7210    /// S3 Outposts bucketAlias Real Outpost Prod us-west-1
7211    #[test]
7212    fn test_261() {
7213        let params = crate::config::endpoint::Params::builder()
7214            .region("us-west-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.us-west-1.amazonaws.com");
7224        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")
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(), "us-west-1".to_string().into());
7238        out.insert("disableDoubleEncoding".to_string(), true.into());
7239        out
7240    })])
7241    .build());
7242    }
7243
7244    /// S3 Outposts bucketAlias Real Outpost Prod ap-east-1
7245    #[test]
7246    fn test_262() {
7247        let params = crate::config::endpoint::Params::builder()
7248            .region("ap-east-1".to_string())
7249            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--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-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.ap-east-1.amazonaws.com");
7258        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")
7259    .property("authSchemes", vec![::aws_smithy_types::Document::from( {
7260        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7261        out.insert("name".to_string(), "sigv4a".to_string().into());
7262        out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7263        out.insert("signingRegionSet".to_string(), vec![::aws_smithy_types::Document::from("*".to_string())].into());
7264        out.insert("disableDoubleEncoding".to_string(), true.into());
7265        out
7266    })
7267    ,::aws_smithy_types::Document::from( {
7268        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7269        out.insert("name".to_string(), "sigv4".to_string().into());
7270        out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7271        out.insert("signingRegion".to_string(), "ap-east-1".to_string().into());
7272        out.insert("disableDoubleEncoding".to_string(), true.into());
7273        out
7274    })])
7275    .build());
7276    }
7277
7278    /// S3 Outposts bucketAlias Ec2 Outpost Prod us-east-1
7279    #[test]
7280    fn test_263() {
7281        let params = crate::config::endpoint::Params::builder()
7282            .region("us-east-1".to_string())
7283            .bucket("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7284            .use_fips(false)
7285            .use_dual_stack(false)
7286            .accelerate(false)
7287            .build()
7288            .expect("invalid params");
7289        let resolver = crate::config::endpoint::DefaultResolver::new();
7290        let endpoint = resolver.resolve_endpoint(&params);
7291        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.us-east-1.amazonaws.com");
7292        assert_eq!(
7293            endpoint,
7294            ::aws_smithy_types::endpoint::Endpoint::builder()
7295                .url("https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.us-east-1.amazonaws.com")
7296                .property(
7297                    "authSchemes",
7298                    vec![
7299                        ::aws_smithy_types::Document::from({
7300                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7301                            out.insert("name".to_string(), "sigv4a".to_string().into());
7302                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7303                            out.insert(
7304                                "signingRegionSet".to_string(),
7305                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
7306                            );
7307                            out.insert("disableDoubleEncoding".to_string(), true.into());
7308                            out
7309                        }),
7310                        ::aws_smithy_types::Document::from({
7311                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7312                            out.insert("name".to_string(), "sigv4".to_string().into());
7313                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7314                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7315                            out.insert("disableDoubleEncoding".to_string(), true.into());
7316                            out
7317                        })
7318                    ]
7319                )
7320                .build()
7321        );
7322    }
7323
7324    /// S3 Outposts bucketAlias Ec2 Outpost Prod me-south-1
7325    #[test]
7326    fn test_264() {
7327        let params = crate::config::endpoint::Params::builder()
7328            .region("me-south-1".to_string())
7329            .bucket("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7330            .use_fips(false)
7331            .use_dual_stack(false)
7332            .accelerate(false)
7333            .build()
7334            .expect("invalid params");
7335        let resolver = crate::config::endpoint::DefaultResolver::new();
7336        let endpoint = resolver.resolve_endpoint(&params);
7337        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.me-south-1.amazonaws.com");
7338        assert_eq!(
7339            endpoint,
7340            ::aws_smithy_types::endpoint::Endpoint::builder()
7341                .url("https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.me-south-1.amazonaws.com")
7342                .property(
7343                    "authSchemes",
7344                    vec![
7345                        ::aws_smithy_types::Document::from({
7346                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7347                            out.insert("name".to_string(), "sigv4a".to_string().into());
7348                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7349                            out.insert(
7350                                "signingRegionSet".to_string(),
7351                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
7352                            );
7353                            out.insert("disableDoubleEncoding".to_string(), true.into());
7354                            out
7355                        }),
7356                        ::aws_smithy_types::Document::from({
7357                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7358                            out.insert("name".to_string(), "sigv4".to_string().into());
7359                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7360                            out.insert("signingRegion".to_string(), "me-south-1".to_string().into());
7361                            out.insert("disableDoubleEncoding".to_string(), true.into());
7362                            out
7363                        })
7364                    ]
7365                )
7366                .build()
7367        );
7368    }
7369
7370    /// S3 Outposts bucketAlias Real Outpost Beta
7371    #[test]
7372    fn test_265() {
7373        let params = crate::config::endpoint::Params::builder()
7374            .region("us-east-1".to_string())
7375            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
7376            .endpoint("https://example.amazonaws.com".to_string())
7377            .use_fips(false)
7378            .use_dual_stack(false)
7379            .accelerate(false)
7380            .build()
7381            .expect("invalid params");
7382        let resolver = crate::config::endpoint::DefaultResolver::new();
7383        let endpoint = resolver.resolve_endpoint(&params);
7384        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3.op-0b1d075431d83bebd.example.amazonaws.com");
7385        assert_eq!(
7386            endpoint,
7387            ::aws_smithy_types::endpoint::Endpoint::builder()
7388                .url("https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3.op-0b1d075431d83bebd.example.amazonaws.com")
7389                .property(
7390                    "authSchemes",
7391                    vec![
7392                        ::aws_smithy_types::Document::from({
7393                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7394                            out.insert("name".to_string(), "sigv4a".to_string().into());
7395                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7396                            out.insert(
7397                                "signingRegionSet".to_string(),
7398                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
7399                            );
7400                            out.insert("disableDoubleEncoding".to_string(), true.into());
7401                            out
7402                        }),
7403                        ::aws_smithy_types::Document::from({
7404                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7405                            out.insert("name".to_string(), "sigv4".to_string().into());
7406                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7407                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7408                            out.insert("disableDoubleEncoding".to_string(), true.into());
7409                            out
7410                        })
7411                    ]
7412                )
7413                .build()
7414        );
7415    }
7416
7417    /// S3 Outposts bucketAlias Ec2 Outpost Beta
7418    #[test]
7419    fn test_266() {
7420        let params = crate::config::endpoint::Params::builder()
7421            .region("us-east-1".to_string())
7422            .bucket("161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3".to_string())
7423            .endpoint("https://example.amazonaws.com".to_string())
7424            .use_fips(false)
7425            .use_dual_stack(false)
7426            .accelerate(false)
7427            .build()
7428            .expect("invalid params");
7429        let resolver = crate::config::endpoint::DefaultResolver::new();
7430        let endpoint = resolver.resolve_endpoint(&params);
7431        let endpoint = endpoint
7432            .expect("Expected valid endpoint: https://161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3.ec2.example.amazonaws.com");
7433        assert_eq!(
7434            endpoint,
7435            ::aws_smithy_types::endpoint::Endpoint::builder()
7436                .url("https://161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3.ec2.example.amazonaws.com")
7437                .property(
7438                    "authSchemes",
7439                    vec![
7440                        ::aws_smithy_types::Document::from({
7441                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7442                            out.insert("name".to_string(), "sigv4a".to_string().into());
7443                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7444                            out.insert(
7445                                "signingRegionSet".to_string(),
7446                                vec![::aws_smithy_types::Document::from("*".to_string())].into(),
7447                            );
7448                            out.insert("disableDoubleEncoding".to_string(), true.into());
7449                            out
7450                        }),
7451                        ::aws_smithy_types::Document::from({
7452                            let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7453                            out.insert("name".to_string(), "sigv4".to_string().into());
7454                            out.insert("signingName".to_string(), "s3-outposts".to_string().into());
7455                            out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7456                            out.insert("disableDoubleEncoding".to_string(), true.into());
7457                            out
7458                        })
7459                    ]
7460                )
7461                .build()
7462        );
7463    }
7464
7465    /// S3 Outposts bucketAlias - No endpoint set for beta
7466    #[test]
7467    fn test_267() {
7468        let params = crate::config::endpoint::Params::builder()
7469            .region("us-east-1".to_string())
7470            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
7471            .use_fips(false)
7472            .use_dual_stack(false)
7473            .accelerate(false)
7474            .build()
7475            .expect("invalid params");
7476        let resolver = crate::config::endpoint::DefaultResolver::new();
7477        let endpoint = resolver.resolve_endpoint(&params);
7478        let error = endpoint.expect_err(
7479            "expected error: Expected a endpoint to be specified but no endpoint was found [S3 Outposts bucketAlias - No endpoint set for beta]",
7480        );
7481        assert_eq!(format!("{}", error), "Expected a endpoint to be specified but no endpoint was found")
7482    }
7483
7484    /// S3 Outposts bucketAlias Invalid hardware type
7485    #[test]
7486    fn test_268() {
7487        let params = crate::config::endpoint::Params::builder()
7488            .region("us-east-1".to_string())
7489            .bucket("test-accessp-h0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7490            .use_fips(false)
7491            .use_dual_stack(false)
7492            .accelerate(false)
7493            .build()
7494            .expect("invalid params");
7495        let resolver = crate::config::endpoint::DefaultResolver::new();
7496        let endpoint = resolver.resolve_endpoint(&params);
7497        let error = endpoint.expect_err(
7498            "expected error: Unrecognized hardware type: \"Expected hardware type o or e but got h\" [S3 Outposts bucketAlias Invalid hardware type]",
7499        );
7500        assert_eq!(
7501            format!("{}", error),
7502            "Unrecognized hardware type: \"Expected hardware type o or e but got h\""
7503        )
7504    }
7505
7506    /// S3 Outposts bucketAlias Special character in Outpost Arn
7507    #[test]
7508    fn test_269() {
7509        let params = crate::config::endpoint::Params::builder()
7510            .region("us-east-1".to_string())
7511            .bucket("test-accessp-o00000754%1d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
7512            .use_fips(false)
7513            .use_dual_stack(false)
7514            .accelerate(false)
7515            .build()
7516            .expect("invalid params");
7517        let resolver = crate::config::endpoint::DefaultResolver::new();
7518        let endpoint = resolver.resolve_endpoint(&params);
7519        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]");
7520        assert_eq!(
7521            format!("{}", error),
7522            "Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`."
7523        )
7524    }
7525
7526    /// S3 Outposts bucketAlias - No endpoint set for beta
7527    #[test]
7528    fn test_270() {
7529        let params = crate::config::endpoint::Params::builder()
7530            .region("us-east-1".to_string())
7531            .bucket("test-accessp-e0b1d075431d83bebde8xz5w8ijx1qzlbp3i3ebeta0--op-s3".to_string())
7532            .use_fips(false)
7533            .use_dual_stack(false)
7534            .accelerate(false)
7535            .build()
7536            .expect("invalid params");
7537        let resolver = crate::config::endpoint::DefaultResolver::new();
7538        let endpoint = resolver.resolve_endpoint(&params);
7539        let error = endpoint.expect_err(
7540            "expected error: Expected a endpoint to be specified but no endpoint was found [S3 Outposts bucketAlias - No endpoint set for beta]",
7541        );
7542        assert_eq!(format!("{}", error), "Expected a endpoint to be specified but no endpoint was found")
7543    }
7544
7545    /// S3 Snow with bucket
7546    #[test]
7547    fn test_271() {
7548        let params = crate::config::endpoint::Params::builder()
7549            .region("snow".to_string())
7550            .bucket("bucketName".to_string())
7551            .endpoint("http://10.0.1.12:433".to_string())
7552            .use_fips(false)
7553            .use_dual_stack(false)
7554            .accelerate(false)
7555            .build()
7556            .expect("invalid params");
7557        let resolver = crate::config::endpoint::DefaultResolver::new();
7558        let endpoint = resolver.resolve_endpoint(&params);
7559        let endpoint = endpoint.expect("Expected valid endpoint: http://10.0.1.12:433/bucketName");
7560        assert_eq!(
7561            endpoint,
7562            ::aws_smithy_types::endpoint::Endpoint::builder()
7563                .url("http://10.0.1.12:433/bucketName")
7564                .property(
7565                    "authSchemes",
7566                    vec![::aws_smithy_types::Document::from({
7567                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7568                        out.insert("name".to_string(), "sigv4".to_string().into());
7569                        out.insert("signingName".to_string(), "s3".to_string().into());
7570                        out.insert("signingRegion".to_string(), "snow".to_string().into());
7571                        out.insert("disableDoubleEncoding".to_string(), true.into());
7572                        out
7573                    })]
7574                )
7575                .build()
7576        );
7577    }
7578
7579    /// S3 Snow without bucket
7580    #[test]
7581    fn test_272() {
7582        let params = crate::config::endpoint::Params::builder()
7583            .region("snow".to_string())
7584            .endpoint("https://10.0.1.12:433".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: https://10.0.1.12:433");
7593        assert_eq!(
7594            endpoint,
7595            ::aws_smithy_types::endpoint::Endpoint::builder()
7596                .url("https://10.0.1.12:433")
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 no port
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("http://10.0.1.12".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: http://10.0.1.12/bucketName");
7627        assert_eq!(
7628            endpoint,
7629            ::aws_smithy_types::endpoint::Endpoint::builder()
7630                .url("http://10.0.1.12/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    /// S3 Snow dns endpoint
7647    #[test]
7648    fn test_274() {
7649        let params = crate::config::endpoint::Params::builder()
7650            .region("snow".to_string())
7651            .bucket("bucketName".to_string())
7652            .endpoint("https://amazonaws.com".to_string())
7653            .use_fips(false)
7654            .use_dual_stack(false)
7655            .accelerate(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://amazonaws.com/bucketName");
7661        assert_eq!(
7662            endpoint,
7663            ::aws_smithy_types::endpoint::Endpoint::builder()
7664                .url("https://amazonaws.com/bucketName")
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".to_string().into());
7670                        out.insert("signingName".to_string(), "s3".to_string().into());
7671                        out.insert("signingRegion".to_string(), "snow".to_string().into());
7672                        out.insert("disableDoubleEncoding".to_string(), true.into());
7673                        out
7674                    })]
7675                )
7676                .build()
7677        );
7678    }
7679
7680    /// Data Plane with short AZ
7681    #[test]
7682    fn test_275() {
7683        let params = crate::config::endpoint::Params::builder()
7684            .region("us-east-1".to_string())
7685            .bucket("mybucket--use1-az1--x-s3".to_string())
7686            .use_fips(false)
7687            .use_dual_stack(false)
7688            .accelerate(false)
7689            .use_s3_express_control_endpoint(false)
7690            .build()
7691            .expect("invalid params");
7692        let resolver = crate::config::endpoint::DefaultResolver::new();
7693        let endpoint = resolver.resolve_endpoint(&params);
7694        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--use1-az1--x-s3.s3express-use1-az1.us-east-1.amazonaws.com");
7695        assert_eq!(
7696            endpoint,
7697            ::aws_smithy_types::endpoint::Endpoint::builder()
7698                .url("https://mybucket--use1-az1--x-s3.s3express-use1-az1.us-east-1.amazonaws.com")
7699                .property(
7700                    "authSchemes",
7701                    vec![::aws_smithy_types::Document::from({
7702                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7703                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7704                        out.insert("signingName".to_string(), "s3express".to_string().into());
7705                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7706                        out.insert("disableDoubleEncoding".to_string(), true.into());
7707                        out
7708                    })]
7709                )
7710                .property("backend", "S3Express".to_string())
7711                .build()
7712        );
7713    }
7714
7715    /// Data Plane with short AZ fips
7716    #[test]
7717    fn test_276() {
7718        let params = crate::config::endpoint::Params::builder()
7719            .region("us-east-1".to_string())
7720            .bucket("mybucket--use1-az1--x-s3".to_string())
7721            .use_fips(true)
7722            .use_dual_stack(false)
7723            .accelerate(false)
7724            .use_s3_express_control_endpoint(false)
7725            .build()
7726            .expect("invalid params");
7727        let resolver = crate::config::endpoint::DefaultResolver::new();
7728        let endpoint = resolver.resolve_endpoint(&params);
7729        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--use1-az1--x-s3.s3express-fips-use1-az1.us-east-1.amazonaws.com");
7730        assert_eq!(
7731            endpoint,
7732            ::aws_smithy_types::endpoint::Endpoint::builder()
7733                .url("https://mybucket--use1-az1--x-s3.s3express-fips-use1-az1.us-east-1.amazonaws.com")
7734                .property(
7735                    "authSchemes",
7736                    vec![::aws_smithy_types::Document::from({
7737                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7738                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7739                        out.insert("signingName".to_string(), "s3express".to_string().into());
7740                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7741                        out.insert("disableDoubleEncoding".to_string(), true.into());
7742                        out
7743                    })]
7744                )
7745                .property("backend", "S3Express".to_string())
7746                .build()
7747        );
7748    }
7749
7750    /// Data Plane with long AZ
7751    #[test]
7752    fn test_277() {
7753        let params = crate::config::endpoint::Params::builder()
7754            .region("ap-northeast-1".to_string())
7755            .bucket("mybucket--apne1-az1--x-s3".to_string())
7756            .use_fips(false)
7757            .use_dual_stack(false)
7758            .accelerate(false)
7759            .use_s3_express_control_endpoint(false)
7760            .build()
7761            .expect("invalid params");
7762        let resolver = crate::config::endpoint::DefaultResolver::new();
7763        let endpoint = resolver.resolve_endpoint(&params);
7764        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--apne1-az1--x-s3.s3express-apne1-az1.ap-northeast-1.amazonaws.com");
7765        assert_eq!(
7766            endpoint,
7767            ::aws_smithy_types::endpoint::Endpoint::builder()
7768                .url("https://mybucket--apne1-az1--x-s3.s3express-apne1-az1.ap-northeast-1.amazonaws.com")
7769                .property(
7770                    "authSchemes",
7771                    vec![::aws_smithy_types::Document::from({
7772                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7773                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7774                        out.insert("signingName".to_string(), "s3express".to_string().into());
7775                        out.insert("signingRegion".to_string(), "ap-northeast-1".to_string().into());
7776                        out.insert("disableDoubleEncoding".to_string(), true.into());
7777                        out
7778                    })]
7779                )
7780                .property("backend", "S3Express".to_string())
7781                .build()
7782        );
7783    }
7784
7785    /// Data Plane with long AZ fips
7786    #[test]
7787    fn test_278() {
7788        let params = crate::config::endpoint::Params::builder()
7789            .region("ap-northeast-1".to_string())
7790            .bucket("mybucket--apne1-az1--x-s3".to_string())
7791            .use_fips(true)
7792            .use_dual_stack(false)
7793            .accelerate(false)
7794            .use_s3_express_control_endpoint(false)
7795            .build()
7796            .expect("invalid params");
7797        let resolver = crate::config::endpoint::DefaultResolver::new();
7798        let endpoint = resolver.resolve_endpoint(&params);
7799        let endpoint =
7800            endpoint.expect("Expected valid endpoint: https://mybucket--apne1-az1--x-s3.s3express-fips-apne1-az1.ap-northeast-1.amazonaws.com");
7801        assert_eq!(
7802            endpoint,
7803            ::aws_smithy_types::endpoint::Endpoint::builder()
7804                .url("https://mybucket--apne1-az1--x-s3.s3express-fips-apne1-az1.ap-northeast-1.amazonaws.com")
7805                .property(
7806                    "authSchemes",
7807                    vec![::aws_smithy_types::Document::from({
7808                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7809                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7810                        out.insert("signingName".to_string(), "s3express".to_string().into());
7811                        out.insert("signingRegion".to_string(), "ap-northeast-1".to_string().into());
7812                        out.insert("disableDoubleEncoding".to_string(), true.into());
7813                        out
7814                    })]
7815                )
7816                .property("backend", "S3Express".to_string())
7817                .build()
7818        );
7819    }
7820
7821    /// Control plane with short AZ bucket
7822    #[test]
7823    fn test_279() {
7824        let params = crate::config::endpoint::Params::builder()
7825            .region("us-east-1".to_string())
7826            .bucket("mybucket--use1-az1--x-s3".to_string())
7827            .use_fips(false)
7828            .use_dual_stack(false)
7829            .accelerate(false)
7830            .use_s3_express_control_endpoint(true)
7831            .disable_s3_express_session_auth(false)
7832            .build()
7833            .expect("invalid params");
7834        let resolver = crate::config::endpoint::DefaultResolver::new();
7835        let endpoint = resolver.resolve_endpoint(&params);
7836        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com/mybucket--use1-az1--x-s3");
7837        assert_eq!(
7838            endpoint,
7839            ::aws_smithy_types::endpoint::Endpoint::builder()
7840                .url("https://s3express-control.us-east-1.amazonaws.com/mybucket--use1-az1--x-s3")
7841                .property(
7842                    "authSchemes",
7843                    vec![::aws_smithy_types::Document::from({
7844                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7845                        out.insert("name".to_string(), "sigv4".to_string().into());
7846                        out.insert("signingName".to_string(), "s3express".to_string().into());
7847                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7848                        out.insert("disableDoubleEncoding".to_string(), true.into());
7849                        out
7850                    })]
7851                )
7852                .property("backend", "S3Express".to_string())
7853                .build()
7854        );
7855    }
7856
7857    /// Control plane with short AZ bucket and fips
7858    #[test]
7859    fn test_280() {
7860        let params = crate::config::endpoint::Params::builder()
7861            .region("us-east-1".to_string())
7862            .bucket("mybucket--use1-az1--x-s3".to_string())
7863            .use_fips(true)
7864            .use_dual_stack(false)
7865            .accelerate(false)
7866            .use_s3_express_control_endpoint(true)
7867            .disable_s3_express_session_auth(false)
7868            .build()
7869            .expect("invalid params");
7870        let resolver = crate::config::endpoint::DefaultResolver::new();
7871        let endpoint = resolver.resolve_endpoint(&params);
7872        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--use1-az1--x-s3");
7873        assert_eq!(
7874            endpoint,
7875            ::aws_smithy_types::endpoint::Endpoint::builder()
7876                .url("https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--use1-az1--x-s3")
7877                .property(
7878                    "authSchemes",
7879                    vec![::aws_smithy_types::Document::from({
7880                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7881                        out.insert("name".to_string(), "sigv4".to_string().into());
7882                        out.insert("signingName".to_string(), "s3express".to_string().into());
7883                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7884                        out.insert("disableDoubleEncoding".to_string(), true.into());
7885                        out
7886                    })]
7887                )
7888                .property("backend", "S3Express".to_string())
7889                .build()
7890        );
7891    }
7892
7893    /// Control plane without bucket
7894    #[test]
7895    fn test_281() {
7896        let params = crate::config::endpoint::Params::builder()
7897            .region("us-east-1".to_string())
7898            .use_fips(false)
7899            .use_dual_stack(false)
7900            .accelerate(false)
7901            .use_s3_express_control_endpoint(true)
7902            .disable_s3_express_session_auth(false)
7903            .build()
7904            .expect("invalid params");
7905        let resolver = crate::config::endpoint::DefaultResolver::new();
7906        let endpoint = resolver.resolve_endpoint(&params);
7907        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com");
7908        assert_eq!(
7909            endpoint,
7910            ::aws_smithy_types::endpoint::Endpoint::builder()
7911                .url("https://s3express-control.us-east-1.amazonaws.com")
7912                .property(
7913                    "authSchemes",
7914                    vec![::aws_smithy_types::Document::from({
7915                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7916                        out.insert("name".to_string(), "sigv4".to_string().into());
7917                        out.insert("signingName".to_string(), "s3express".to_string().into());
7918                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7919                        out.insert("disableDoubleEncoding".to_string(), true.into());
7920                        out
7921                    })]
7922                )
7923                .property("backend", "S3Express".to_string())
7924                .build()
7925        );
7926    }
7927
7928    /// Control plane without bucket and fips
7929    #[test]
7930    fn test_282() {
7931        let params = crate::config::endpoint::Params::builder()
7932            .region("us-east-1".to_string())
7933            .use_fips(true)
7934            .use_dual_stack(false)
7935            .accelerate(false)
7936            .use_s3_express_control_endpoint(true)
7937            .disable_s3_express_session_auth(false)
7938            .build()
7939            .expect("invalid params");
7940        let resolver = crate::config::endpoint::DefaultResolver::new();
7941        let endpoint = resolver.resolve_endpoint(&params);
7942        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com");
7943        assert_eq!(
7944            endpoint,
7945            ::aws_smithy_types::endpoint::Endpoint::builder()
7946                .url("https://s3express-control-fips.us-east-1.amazonaws.com")
7947                .property(
7948                    "authSchemes",
7949                    vec![::aws_smithy_types::Document::from({
7950                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7951                        out.insert("name".to_string(), "sigv4".to_string().into());
7952                        out.insert("signingName".to_string(), "s3express".to_string().into());
7953                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7954                        out.insert("disableDoubleEncoding".to_string(), true.into());
7955                        out
7956                    })]
7957                )
7958                .property("backend", "S3Express".to_string())
7959                .build()
7960        );
7961    }
7962
7963    /// Data Plane sigv4 auth with short AZ
7964    #[test]
7965    fn test_283() {
7966        let params = crate::config::endpoint::Params::builder()
7967            .region("us-west-2".to_string())
7968            .bucket("mybucket--usw2-az1--x-s3".to_string())
7969            .use_fips(false)
7970            .use_dual_stack(false)
7971            .accelerate(false)
7972            .disable_s3_express_session_auth(true)
7973            .build()
7974            .expect("invalid params");
7975        let resolver = crate::config::endpoint::DefaultResolver::new();
7976        let endpoint = resolver.resolve_endpoint(&params);
7977        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com");
7978        assert_eq!(
7979            endpoint,
7980            ::aws_smithy_types::endpoint::Endpoint::builder()
7981                .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com")
7982                .property(
7983                    "authSchemes",
7984                    vec![::aws_smithy_types::Document::from({
7985                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7986                        out.insert("name".to_string(), "sigv4".to_string().into());
7987                        out.insert("signingName".to_string(), "s3express".to_string().into());
7988                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7989                        out.insert("disableDoubleEncoding".to_string(), true.into());
7990                        out
7991                    })]
7992                )
7993                .property("backend", "S3Express".to_string())
7994                .build()
7995        );
7996    }
7997
7998    /// Data Plane sigv4 auth with short AZ fips
7999    #[test]
8000    fn test_284() {
8001        let params = crate::config::endpoint::Params::builder()
8002            .region("us-west-2".to_string())
8003            .bucket("mybucket--usw2-az1--x-s3".to_string())
8004            .use_fips(true)
8005            .use_dual_stack(false)
8006            .accelerate(false)
8007            .disable_s3_express_session_auth(true)
8008            .build()
8009            .expect("invalid params");
8010        let resolver = crate::config::endpoint::DefaultResolver::new();
8011        let endpoint = resolver.resolve_endpoint(&params);
8012        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com");
8013        assert_eq!(
8014            endpoint,
8015            ::aws_smithy_types::endpoint::Endpoint::builder()
8016                .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com")
8017                .property(
8018                    "authSchemes",
8019                    vec![::aws_smithy_types::Document::from({
8020                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8021                        out.insert("name".to_string(), "sigv4".to_string().into());
8022                        out.insert("signingName".to_string(), "s3express".to_string().into());
8023                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8024                        out.insert("disableDoubleEncoding".to_string(), true.into());
8025                        out
8026                    })]
8027                )
8028                .property("backend", "S3Express".to_string())
8029                .build()
8030        );
8031    }
8032
8033    /// Data Plane sigv4 auth with long AZ
8034    #[test]
8035    fn test_285() {
8036        let params = crate::config::endpoint::Params::builder()
8037            .region("ap-northeast-1".to_string())
8038            .bucket("mybucket--apne1-az1--x-s3".to_string())
8039            .use_fips(false)
8040            .use_dual_stack(false)
8041            .accelerate(false)
8042            .use_s3_express_control_endpoint(false)
8043            .disable_s3_express_session_auth(true)
8044            .build()
8045            .expect("invalid params");
8046        let resolver = crate::config::endpoint::DefaultResolver::new();
8047        let endpoint = resolver.resolve_endpoint(&params);
8048        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--apne1-az1--x-s3.s3express-apne1-az1.ap-northeast-1.amazonaws.com");
8049        assert_eq!(
8050            endpoint,
8051            ::aws_smithy_types::endpoint::Endpoint::builder()
8052                .url("https://mybucket--apne1-az1--x-s3.s3express-apne1-az1.ap-northeast-1.amazonaws.com")
8053                .property(
8054                    "authSchemes",
8055                    vec![::aws_smithy_types::Document::from({
8056                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8057                        out.insert("name".to_string(), "sigv4".to_string().into());
8058                        out.insert("signingName".to_string(), "s3express".to_string().into());
8059                        out.insert("signingRegion".to_string(), "ap-northeast-1".to_string().into());
8060                        out.insert("disableDoubleEncoding".to_string(), true.into());
8061                        out
8062                    })]
8063                )
8064                .property("backend", "S3Express".to_string())
8065                .build()
8066        );
8067    }
8068
8069    /// Data Plane sigv4 auth with long AZ fips
8070    #[test]
8071    fn test_286() {
8072        let params = crate::config::endpoint::Params::builder()
8073            .region("ap-northeast-1".to_string())
8074            .bucket("mybucket--apne1-az1--x-s3".to_string())
8075            .use_fips(true)
8076            .use_dual_stack(false)
8077            .accelerate(false)
8078            .use_s3_express_control_endpoint(false)
8079            .disable_s3_express_session_auth(true)
8080            .build()
8081            .expect("invalid params");
8082        let resolver = crate::config::endpoint::DefaultResolver::new();
8083        let endpoint = resolver.resolve_endpoint(&params);
8084        let endpoint =
8085            endpoint.expect("Expected valid endpoint: https://mybucket--apne1-az1--x-s3.s3express-fips-apne1-az1.ap-northeast-1.amazonaws.com");
8086        assert_eq!(
8087            endpoint,
8088            ::aws_smithy_types::endpoint::Endpoint::builder()
8089                .url("https://mybucket--apne1-az1--x-s3.s3express-fips-apne1-az1.ap-northeast-1.amazonaws.com")
8090                .property(
8091                    "authSchemes",
8092                    vec![::aws_smithy_types::Document::from({
8093                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8094                        out.insert("name".to_string(), "sigv4".to_string().into());
8095                        out.insert("signingName".to_string(), "s3express".to_string().into());
8096                        out.insert("signingRegion".to_string(), "ap-northeast-1".to_string().into());
8097                        out.insert("disableDoubleEncoding".to_string(), true.into());
8098                        out
8099                    })]
8100                )
8101                .property("backend", "S3Express".to_string())
8102                .build()
8103        );
8104    }
8105
8106    /// Control Plane host override
8107    #[test]
8108    fn test_287() {
8109        let params = crate::config::endpoint::Params::builder()
8110            .region("us-west-2".to_string())
8111            .bucket("mybucket--usw2-az1--x-s3".to_string())
8112            .use_fips(false)
8113            .use_dual_stack(false)
8114            .accelerate(false)
8115            .use_s3_express_control_endpoint(true)
8116            .disable_s3_express_session_auth(true)
8117            .endpoint("https://custom.com".to_string())
8118            .build()
8119            .expect("invalid params");
8120        let resolver = crate::config::endpoint::DefaultResolver::new();
8121        let endpoint = resolver.resolve_endpoint(&params);
8122        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
8123        assert_eq!(
8124            endpoint,
8125            ::aws_smithy_types::endpoint::Endpoint::builder()
8126                .url("https://mybucket--usw2-az1--x-s3.custom.com")
8127                .property(
8128                    "authSchemes",
8129                    vec![::aws_smithy_types::Document::from({
8130                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8131                        out.insert("name".to_string(), "sigv4".to_string().into());
8132                        out.insert("signingName".to_string(), "s3express".to_string().into());
8133                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8134                        out.insert("disableDoubleEncoding".to_string(), true.into());
8135                        out
8136                    })]
8137                )
8138                .property("backend", "S3Express".to_string())
8139                .build()
8140        );
8141    }
8142
8143    /// Control Plane host override no bucket
8144    #[test]
8145    fn test_288() {
8146        let params = crate::config::endpoint::Params::builder()
8147            .region("us-west-2".to_string())
8148            .use_fips(false)
8149            .use_dual_stack(false)
8150            .accelerate(false)
8151            .use_s3_express_control_endpoint(true)
8152            .disable_s3_express_session_auth(true)
8153            .endpoint("https://custom.com".to_string())
8154            .build()
8155            .expect("invalid params");
8156        let resolver = crate::config::endpoint::DefaultResolver::new();
8157        let endpoint = resolver.resolve_endpoint(&params);
8158        let endpoint = endpoint.expect("Expected valid endpoint: https://custom.com");
8159        assert_eq!(
8160            endpoint,
8161            ::aws_smithy_types::endpoint::Endpoint::builder()
8162                .url("https://custom.com")
8163                .property(
8164                    "authSchemes",
8165                    vec![::aws_smithy_types::Document::from({
8166                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8167                        out.insert("name".to_string(), "sigv4".to_string().into());
8168                        out.insert("signingName".to_string(), "s3express".to_string().into());
8169                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8170                        out.insert("disableDoubleEncoding".to_string(), true.into());
8171                        out
8172                    })]
8173                )
8174                .property("backend", "S3Express".to_string())
8175                .build()
8176        );
8177    }
8178
8179    /// Data plane host override non virtual session auth
8180    #[test]
8181    fn test_289() {
8182        let params = crate::config::endpoint::Params::builder()
8183            .region("us-west-2".to_string())
8184            .bucket("mybucket--usw2-az1--x-s3".to_string())
8185            .use_fips(false)
8186            .use_dual_stack(false)
8187            .accelerate(false)
8188            .endpoint("https://10.0.0.1".to_string())
8189            .build()
8190            .expect("invalid params");
8191        let resolver = crate::config::endpoint::DefaultResolver::new();
8192        let endpoint = resolver.resolve_endpoint(&params);
8193        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
8194        assert_eq!(
8195            endpoint,
8196            ::aws_smithy_types::endpoint::Endpoint::builder()
8197                .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
8198                .property(
8199                    "authSchemes",
8200                    vec![::aws_smithy_types::Document::from({
8201                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8202                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8203                        out.insert("signingName".to_string(), "s3express".to_string().into());
8204                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8205                        out.insert("disableDoubleEncoding".to_string(), true.into());
8206                        out
8207                    })]
8208                )
8209                .property("backend", "S3Express".to_string())
8210                .build()
8211        );
8212    }
8213
8214    /// Control Plane host override ip
8215    #[test]
8216    fn test_290() {
8217        let params = crate::config::endpoint::Params::builder()
8218            .region("us-west-2".to_string())
8219            .bucket("mybucket--usw2-az1--x-s3".to_string())
8220            .use_fips(false)
8221            .use_dual_stack(false)
8222            .accelerate(false)
8223            .use_s3_express_control_endpoint(true)
8224            .disable_s3_express_session_auth(true)
8225            .endpoint("https://10.0.0.1".to_string())
8226            .build()
8227            .expect("invalid params");
8228        let resolver = crate::config::endpoint::DefaultResolver::new();
8229        let endpoint = resolver.resolve_endpoint(&params);
8230        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
8231        assert_eq!(
8232            endpoint,
8233            ::aws_smithy_types::endpoint::Endpoint::builder()
8234                .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
8235                .property(
8236                    "authSchemes",
8237                    vec![::aws_smithy_types::Document::from({
8238                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8239                        out.insert("name".to_string(), "sigv4".to_string().into());
8240                        out.insert("signingName".to_string(), "s3express".to_string().into());
8241                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8242                        out.insert("disableDoubleEncoding".to_string(), true.into());
8243                        out
8244                    })]
8245                )
8246                .property("backend", "S3Express".to_string())
8247                .build()
8248        );
8249    }
8250
8251    /// Data plane host override
8252    #[test]
8253    fn test_291() {
8254        let params = crate::config::endpoint::Params::builder()
8255            .region("us-west-2".to_string())
8256            .bucket("mybucket--usw2-az1--x-s3".to_string())
8257            .use_fips(false)
8258            .use_dual_stack(false)
8259            .accelerate(false)
8260            .endpoint("https://custom.com".to_string())
8261            .build()
8262            .expect("invalid params");
8263        let resolver = crate::config::endpoint::DefaultResolver::new();
8264        let endpoint = resolver.resolve_endpoint(&params);
8265        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
8266        assert_eq!(
8267            endpoint,
8268            ::aws_smithy_types::endpoint::Endpoint::builder()
8269                .url("https://mybucket--usw2-az1--x-s3.custom.com")
8270                .property(
8271                    "authSchemes",
8272                    vec![::aws_smithy_types::Document::from({
8273                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8274                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8275                        out.insert("signingName".to_string(), "s3express".to_string().into());
8276                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8277                        out.insert("disableDoubleEncoding".to_string(), true.into());
8278                        out
8279                    })]
8280                )
8281                .property("backend", "S3Express".to_string())
8282                .build()
8283        );
8284    }
8285
8286    /// bad format error
8287    #[test]
8288    fn test_292() {
8289        let params = crate::config::endpoint::Params::builder()
8290            .region("us-east-1".to_string())
8291            .bucket("mybucket--usaz1--x-s3".to_string())
8292            .use_fips(false)
8293            .use_dual_stack(false)
8294            .accelerate(false)
8295            .use_s3_express_control_endpoint(false)
8296            .build()
8297            .expect("invalid params");
8298        let resolver = crate::config::endpoint::DefaultResolver::new();
8299        let endpoint = resolver.resolve_endpoint(&params);
8300        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad format error]");
8301        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
8302    }
8303
8304    /// bad format error no session auth
8305    #[test]
8306    fn test_293() {
8307        let params = crate::config::endpoint::Params::builder()
8308            .region("us-east-1".to_string())
8309            .bucket("mybucket--usaz1--x-s3".to_string())
8310            .use_fips(false)
8311            .use_dual_stack(false)
8312            .accelerate(false)
8313            .use_s3_express_control_endpoint(false)
8314            .disable_s3_express_session_auth(true)
8315            .build()
8316            .expect("invalid params");
8317        let resolver = crate::config::endpoint::DefaultResolver::new();
8318        let endpoint = resolver.resolve_endpoint(&params);
8319        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad format error no session auth]");
8320        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
8321    }
8322
8323    /// dual-stack error
8324    #[test]
8325    fn test_294() {
8326        let params = crate::config::endpoint::Params::builder()
8327            .region("us-east-1".to_string())
8328            .bucket("mybucket--use1-az1--x-s3".to_string())
8329            .use_fips(false)
8330            .use_dual_stack(true)
8331            .accelerate(false)
8332            .use_s3_express_control_endpoint(false)
8333            .build()
8334            .expect("invalid params");
8335        let resolver = crate::config::endpoint::DefaultResolver::new();
8336        let endpoint = resolver.resolve_endpoint(&params);
8337        let error = endpoint.expect_err("expected error: S3Express does not support Dual-stack. [dual-stack error]");
8338        assert_eq!(format!("{}", error), "S3Express does not support Dual-stack.")
8339    }
8340
8341    /// accelerate error
8342    #[test]
8343    fn test_295() {
8344        let params = crate::config::endpoint::Params::builder()
8345            .region("us-east-1".to_string())
8346            .bucket("mybucket--use1-az1--x-s3".to_string())
8347            .use_fips(false)
8348            .use_dual_stack(false)
8349            .accelerate(true)
8350            .use_s3_express_control_endpoint(false)
8351            .build()
8352            .expect("invalid params");
8353        let resolver = crate::config::endpoint::DefaultResolver::new();
8354        let endpoint = resolver.resolve_endpoint(&params);
8355        let error = endpoint.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error]");
8356        assert_eq!(format!("{}", error), "S3Express does not support S3 Accelerate.")
8357    }
8358
8359    /// Data plane bucket format error
8360    #[test]
8361    fn test_296() {
8362        let params = crate::config::endpoint::Params::builder()
8363            .region("us-east-1".to_string())
8364            .bucket("my.bucket--use1-az1--x-s3".to_string())
8365            .use_fips(false)
8366            .use_dual_stack(false)
8367            .accelerate(false)
8368            .use_s3_express_control_endpoint(false)
8369            .build()
8370            .expect("invalid params");
8371        let resolver = crate::config::endpoint::DefaultResolver::new();
8372        let endpoint = resolver.resolve_endpoint(&params);
8373        let error =
8374            endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane bucket format error]");
8375        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8376    }
8377
8378    /// host override data plane bucket error session auth
8379    #[test]
8380    fn test_297() {
8381        let params = crate::config::endpoint::Params::builder()
8382            .region("us-west-2".to_string())
8383            .bucket("my.bucket--usw2-az1--x-s3".to_string())
8384            .use_fips(false)
8385            .use_dual_stack(false)
8386            .accelerate(false)
8387            .endpoint("https://custom.com".to_string())
8388            .build()
8389            .expect("invalid params");
8390        let resolver = crate::config::endpoint::DefaultResolver::new();
8391        let endpoint = resolver.resolve_endpoint(&params);
8392        let error = endpoint.expect_err(
8393            "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error session auth]",
8394        );
8395        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8396    }
8397
8398    /// host override data plane bucket error
8399    #[test]
8400    fn test_298() {
8401        let params = crate::config::endpoint::Params::builder()
8402            .region("us-west-2".to_string())
8403            .bucket("my.bucket--usw2-az1--x-s3".to_string())
8404            .use_fips(false)
8405            .use_dual_stack(false)
8406            .accelerate(false)
8407            .endpoint("https://custom.com".to_string())
8408            .disable_s3_express_session_auth(true)
8409            .build()
8410            .expect("invalid params");
8411        let resolver = crate::config::endpoint::DefaultResolver::new();
8412        let endpoint = resolver.resolve_endpoint(&params);
8413        let error = endpoint
8414            .expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error]");
8415        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8416    }
8417}
8418
8419/// Endpoint resolver trait specific to Amazon Simple Storage Service
8420pub trait ResolveEndpoint: ::std::marker::Send + ::std::marker::Sync + ::std::fmt::Debug {
8421    /// Resolve an endpoint with the given parameters
8422    fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a>;
8423
8424    /// Convert this service-specific resolver into a `SharedEndpointResolver`
8425    ///
8426    /// The resulting resolver will downcast `EndpointResolverParams` into `crate::config::endpoint::Params`.
8427    fn into_shared_resolver(self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver
8428    where
8429        Self: Sized + 'static,
8430    {
8431        ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
8432    }
8433}
8434
8435#[derive(Debug)]
8436struct DowncastParams<T>(T);
8437impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
8438where
8439    T: ResolveEndpoint,
8440{
8441    fn resolve_endpoint<'a>(
8442        &'a self,
8443        params: &'a ::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams,
8444    ) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
8445        let ep = match params.get::<crate::config::endpoint::Params>() {
8446            Some(params) => self.0.resolve_endpoint(params),
8447            None => ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(Err("params of expected type was not present".into())),
8448        };
8449        ep
8450    }
8451}
8452
8453/// The default endpoint resolver
8454#[derive(Debug, Default)]
8455pub struct DefaultResolver {
8456    partition_resolver: crate::endpoint_lib::partition::PartitionResolver,
8457}
8458
8459impl DefaultResolver {
8460    /// Create a new endpoint resolver with default settings
8461    pub fn new() -> Self {
8462        Self {
8463            partition_resolver: crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER.clone(),
8464        }
8465    }
8466
8467    fn resolve_endpoint(
8468        &self,
8469        params: &crate::config::endpoint::Params,
8470    ) -> Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_runtime_api::box_error::BoxError> {
8471        let mut diagnostic_collector = crate::endpoint_lib::diagnostic::DiagnosticCollector::new();
8472        Ok(
8473            crate::config::endpoint::internals::resolve_endpoint(params, &mut diagnostic_collector, &self.partition_resolver)
8474                .map_err(|err| err.with_source(diagnostic_collector.take_last_error()))?,
8475        )
8476    }
8477}
8478
8479impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
8480    fn resolve_endpoint(&self, params: &crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture {
8481        ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(self.resolve_endpoint(params))
8482    }
8483}
8484
8485#[non_exhaustive]
8486#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
8487/// Configuration parameters for resolving the correct endpoint
8488pub struct Params {
8489    /// 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.
8490    pub(crate) bucket: ::std::option::Option<::std::string::String>,
8491    /// The AWS region used to dispatch the request.
8492    pub(crate) region: ::std::option::Option<::std::string::String>,
8493    /// 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.
8494    pub(crate) use_fips: bool,
8495    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
8496    pub(crate) use_dual_stack: bool,
8497    /// Override the endpoint used to send this request
8498    pub(crate) endpoint: ::std::option::Option<::std::string::String>,
8499    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
8500    pub(crate) force_path_style: bool,
8501    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
8502    pub(crate) accelerate: bool,
8503    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
8504    pub(crate) use_global_endpoint: bool,
8505    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
8506    pub(crate) use_object_lambda_endpoint: ::std::option::Option<bool>,
8507    /// 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.
8508    pub(crate) key: ::std::option::Option<::std::string::String>,
8509    /// 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.
8510    pub(crate) prefix: ::std::option::Option<::std::string::String>,
8511    /// The Copy Source used for Copy Object request. This is an optional parameter that will be set automatically for operations that are scoped to Copy Source.
8512    pub(crate) copy_source: ::std::option::Option<::std::string::String>,
8513    /// Internal parameter to disable Access Point Buckets
8514    pub(crate) disable_access_points: ::std::option::Option<bool>,
8515    /// Whether multi-region access points (MRAP) should be disabled.
8516    pub(crate) disable_multi_region_access_points: bool,
8517    /// 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.
8518    pub(crate) use_arn_region: ::std::option::Option<bool>,
8519    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
8520    pub(crate) use_s3_express_control_endpoint: ::std::option::Option<bool>,
8521    /// Parameter to indicate whether S3Express session auth should be disabled
8522    pub(crate) disable_s3_express_session_auth: ::std::option::Option<bool>,
8523}
8524impl Params {
8525    /// Create a builder for [`Params`]
8526    pub fn builder() -> crate::config::endpoint::ParamsBuilder {
8527        crate::config::endpoint::ParamsBuilder::default()
8528    }
8529    /// 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.
8530    pub fn bucket(&self) -> ::std::option::Option<&str> {
8531        self.bucket.as_deref()
8532    }
8533    /// The AWS region used to dispatch the request.
8534    pub fn region(&self) -> ::std::option::Option<&str> {
8535        self.region.as_deref()
8536    }
8537    /// 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.
8538    pub fn use_fips(&self) -> ::std::option::Option<bool> {
8539        Some(self.use_fips)
8540    }
8541    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
8542    pub fn use_dual_stack(&self) -> ::std::option::Option<bool> {
8543        Some(self.use_dual_stack)
8544    }
8545    /// Override the endpoint used to send this request
8546    pub fn endpoint(&self) -> ::std::option::Option<&str> {
8547        self.endpoint.as_deref()
8548    }
8549    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
8550    pub fn force_path_style(&self) -> ::std::option::Option<bool> {
8551        Some(self.force_path_style)
8552    }
8553    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
8554    pub fn accelerate(&self) -> ::std::option::Option<bool> {
8555        Some(self.accelerate)
8556    }
8557    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
8558    pub fn use_global_endpoint(&self) -> ::std::option::Option<bool> {
8559        Some(self.use_global_endpoint)
8560    }
8561    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
8562    pub fn use_object_lambda_endpoint(&self) -> ::std::option::Option<bool> {
8563        self.use_object_lambda_endpoint
8564    }
8565    /// 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.
8566    pub fn key(&self) -> ::std::option::Option<&str> {
8567        self.key.as_deref()
8568    }
8569    /// 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.
8570    pub fn prefix(&self) -> ::std::option::Option<&str> {
8571        self.prefix.as_deref()
8572    }
8573    /// The Copy Source used for Copy Object request. This is an optional parameter that will be set automatically for operations that are scoped to Copy Source.
8574    pub fn copy_source(&self) -> ::std::option::Option<&str> {
8575        self.copy_source.as_deref()
8576    }
8577    /// Internal parameter to disable Access Point Buckets
8578    pub fn disable_access_points(&self) -> ::std::option::Option<bool> {
8579        self.disable_access_points
8580    }
8581    /// Whether multi-region access points (MRAP) should be disabled.
8582    pub fn disable_multi_region_access_points(&self) -> ::std::option::Option<bool> {
8583        Some(self.disable_multi_region_access_points)
8584    }
8585    /// 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.
8586    pub fn use_arn_region(&self) -> ::std::option::Option<bool> {
8587        self.use_arn_region
8588    }
8589    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
8590    pub fn use_s3_express_control_endpoint(&self) -> ::std::option::Option<bool> {
8591        self.use_s3_express_control_endpoint
8592    }
8593    /// Parameter to indicate whether S3Express session auth should be disabled
8594    pub fn disable_s3_express_session_auth(&self) -> ::std::option::Option<bool> {
8595        self.disable_s3_express_session_auth
8596    }
8597}
8598
8599/// Builder for [`Params`]
8600#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
8601pub struct ParamsBuilder {
8602    bucket: ::std::option::Option<::std::string::String>,
8603    region: ::std::option::Option<::std::string::String>,
8604    use_fips: ::std::option::Option<bool>,
8605    use_dual_stack: ::std::option::Option<bool>,
8606    endpoint: ::std::option::Option<::std::string::String>,
8607    force_path_style: ::std::option::Option<bool>,
8608    accelerate: ::std::option::Option<bool>,
8609    use_global_endpoint: ::std::option::Option<bool>,
8610    use_object_lambda_endpoint: ::std::option::Option<bool>,
8611    key: ::std::option::Option<::std::string::String>,
8612    prefix: ::std::option::Option<::std::string::String>,
8613    copy_source: ::std::option::Option<::std::string::String>,
8614    disable_access_points: ::std::option::Option<bool>,
8615    disable_multi_region_access_points: ::std::option::Option<bool>,
8616    use_arn_region: ::std::option::Option<bool>,
8617    use_s3_express_control_endpoint: ::std::option::Option<bool>,
8618    disable_s3_express_session_auth: ::std::option::Option<bool>,
8619}
8620impl ParamsBuilder {
8621    /// Consume this builder, creating [`Params`].
8622    pub fn build(self) -> ::std::result::Result<crate::config::endpoint::Params, crate::config::endpoint::InvalidParams> {
8623        Ok(
8624            #[allow(clippy::unnecessary_lazy_evaluations)]
8625            crate::config::endpoint::Params {
8626                bucket: self.bucket,
8627                region: self.region,
8628                use_fips: self
8629                    .use_fips
8630                    .or_else(|| Some(false))
8631                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_fips"))?,
8632                use_dual_stack: self
8633                    .use_dual_stack
8634                    .or_else(|| Some(false))
8635                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_dual_stack"))?,
8636                endpoint: self.endpoint,
8637                force_path_style: self
8638                    .force_path_style
8639                    .or_else(|| Some(false))
8640                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("force_path_style"))?,
8641                accelerate: self
8642                    .accelerate
8643                    .or_else(|| Some(false))
8644                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("accelerate"))?,
8645                use_global_endpoint: self
8646                    .use_global_endpoint
8647                    .or_else(|| Some(false))
8648                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_global_endpoint"))?,
8649                use_object_lambda_endpoint: self.use_object_lambda_endpoint,
8650                key: self.key,
8651                prefix: self.prefix,
8652                copy_source: self.copy_source,
8653                disable_access_points: self.disable_access_points,
8654                disable_multi_region_access_points: self
8655                    .disable_multi_region_access_points
8656                    .or_else(|| Some(false))
8657                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("disable_multi_region_access_points"))?,
8658                use_arn_region: self.use_arn_region,
8659                use_s3_express_control_endpoint: self.use_s3_express_control_endpoint,
8660                disable_s3_express_session_auth: self.disable_s3_express_session_auth,
8661            },
8662        )
8663    }
8664    /// Sets the value for bucket
8665    ///
8666    /// 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.
8667    pub fn bucket(mut self, value: impl Into<::std::string::String>) -> Self {
8668        self.bucket = Some(value.into());
8669        self
8670    }
8671
8672    /// Sets the value for bucket
8673    ///
8674    /// 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.
8675    pub fn set_bucket(mut self, param: Option<::std::string::String>) -> Self {
8676        self.bucket = param;
8677        self
8678    }
8679    /// Sets the value for region
8680    ///
8681    /// The AWS region used to dispatch the request.
8682    pub fn region(mut self, value: impl Into<::std::string::String>) -> Self {
8683        self.region = Some(value.into());
8684        self
8685    }
8686
8687    /// Sets the value for region
8688    ///
8689    /// The AWS region used to dispatch the request.
8690    pub fn set_region(mut self, param: Option<::std::string::String>) -> Self {
8691        self.region = param;
8692        self
8693    }
8694    /// Sets the value for use_fips
8695    ///
8696    /// When unset, this parameter has a default value of `false`.
8697    /// 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.
8698    pub fn use_fips(mut self, value: impl Into<bool>) -> Self {
8699        self.use_fips = Some(value.into());
8700        self
8701    }
8702
8703    /// Sets the value for use_fips
8704    ///
8705    /// When unset, this parameter has a default value of `false`.
8706    /// 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.
8707    pub fn set_use_fips(mut self, param: Option<bool>) -> Self {
8708        self.use_fips = param;
8709        self
8710    }
8711    /// Sets the value for use_dual_stack
8712    ///
8713    /// When unset, this parameter has a default value of `false`.
8714    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
8715    pub fn use_dual_stack(mut self, value: impl Into<bool>) -> Self {
8716        self.use_dual_stack = Some(value.into());
8717        self
8718    }
8719
8720    /// Sets the value for use_dual_stack
8721    ///
8722    /// When unset, this parameter has a default value of `false`.
8723    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
8724    pub fn set_use_dual_stack(mut self, param: Option<bool>) -> Self {
8725        self.use_dual_stack = param;
8726        self
8727    }
8728    /// Sets the value for endpoint
8729    ///
8730    /// Override the endpoint used to send this request
8731    pub fn endpoint(mut self, value: impl Into<::std::string::String>) -> Self {
8732        self.endpoint = Some(value.into());
8733        self
8734    }
8735
8736    /// Sets the value for endpoint
8737    ///
8738    /// Override the endpoint used to send this request
8739    pub fn set_endpoint(mut self, param: Option<::std::string::String>) -> Self {
8740        self.endpoint = param;
8741        self
8742    }
8743    /// Sets the value for force_path_style
8744    ///
8745    /// When unset, this parameter has a default value of `false`.
8746    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
8747    pub fn force_path_style(mut self, value: impl Into<bool>) -> Self {
8748        self.force_path_style = Some(value.into());
8749        self
8750    }
8751
8752    /// Sets the value for force_path_style
8753    ///
8754    /// When unset, this parameter has a default value of `false`.
8755    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
8756    pub fn set_force_path_style(mut self, param: Option<bool>) -> Self {
8757        self.force_path_style = param;
8758        self
8759    }
8760    /// Sets the value for accelerate
8761    ///
8762    /// When unset, this parameter has a default value of `false`.
8763    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
8764    pub fn accelerate(mut self, value: impl Into<bool>) -> Self {
8765        self.accelerate = Some(value.into());
8766        self
8767    }
8768
8769    /// Sets the value for accelerate
8770    ///
8771    /// When unset, this parameter has a default value of `false`.
8772    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
8773    pub fn set_accelerate(mut self, param: Option<bool>) -> Self {
8774        self.accelerate = param;
8775        self
8776    }
8777    /// Sets the value for use_global_endpoint
8778    ///
8779    /// When unset, this parameter has a default value of `false`.
8780    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
8781    pub fn use_global_endpoint(mut self, value: impl Into<bool>) -> Self {
8782        self.use_global_endpoint = Some(value.into());
8783        self
8784    }
8785
8786    /// Sets the value for use_global_endpoint
8787    ///
8788    /// When unset, this parameter has a default value of `false`.
8789    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
8790    pub fn set_use_global_endpoint(mut self, param: Option<bool>) -> Self {
8791        self.use_global_endpoint = param;
8792        self
8793    }
8794    /// Sets the value for use_object_lambda_endpoint
8795    ///
8796    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
8797    pub fn use_object_lambda_endpoint(mut self, value: impl Into<bool>) -> Self {
8798        self.use_object_lambda_endpoint = Some(value.into());
8799        self
8800    }
8801
8802    /// Sets the value for use_object_lambda_endpoint
8803    ///
8804    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
8805    pub fn set_use_object_lambda_endpoint(mut self, param: Option<bool>) -> Self {
8806        self.use_object_lambda_endpoint = param;
8807        self
8808    }
8809    /// Sets the value for key
8810    ///
8811    /// 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.
8812    pub fn key(mut self, value: impl Into<::std::string::String>) -> Self {
8813        self.key = Some(value.into());
8814        self
8815    }
8816
8817    /// Sets the value for key
8818    ///
8819    /// 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.
8820    pub fn set_key(mut self, param: Option<::std::string::String>) -> Self {
8821        self.key = param;
8822        self
8823    }
8824    /// Sets the value for prefix
8825    ///
8826    /// 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.
8827    pub fn prefix(mut self, value: impl Into<::std::string::String>) -> Self {
8828        self.prefix = Some(value.into());
8829        self
8830    }
8831
8832    /// Sets the value for prefix
8833    ///
8834    /// 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.
8835    pub fn set_prefix(mut self, param: Option<::std::string::String>) -> Self {
8836        self.prefix = param;
8837        self
8838    }
8839    /// Sets the value for copy_source
8840    ///
8841    /// The Copy Source used for Copy Object request. This is an optional parameter that will be set automatically for operations that are scoped to Copy Source.
8842    pub fn copy_source(mut self, value: impl Into<::std::string::String>) -> Self {
8843        self.copy_source = Some(value.into());
8844        self
8845    }
8846
8847    /// Sets the value for copy_source
8848    ///
8849    /// The Copy Source used for Copy Object request. This is an optional parameter that will be set automatically for operations that are scoped to Copy Source.
8850    pub fn set_copy_source(mut self, param: Option<::std::string::String>) -> Self {
8851        self.copy_source = param;
8852        self
8853    }
8854    /// Sets the value for disable_access_points
8855    ///
8856    /// Internal parameter to disable Access Point Buckets
8857    pub fn disable_access_points(mut self, value: impl Into<bool>) -> Self {
8858        self.disable_access_points = Some(value.into());
8859        self
8860    }
8861
8862    /// Sets the value for disable_access_points
8863    ///
8864    /// Internal parameter to disable Access Point Buckets
8865    pub fn set_disable_access_points(mut self, param: Option<bool>) -> Self {
8866        self.disable_access_points = param;
8867        self
8868    }
8869    /// Sets the value for disable_multi_region_access_points
8870    ///
8871    /// When unset, this parameter has a default value of `false`.
8872    /// Whether multi-region access points (MRAP) should be disabled.
8873    pub fn disable_multi_region_access_points(mut self, value: impl Into<bool>) -> Self {
8874        self.disable_multi_region_access_points = Some(value.into());
8875        self
8876    }
8877
8878    /// Sets the value for disable_multi_region_access_points
8879    ///
8880    /// When unset, this parameter has a default value of `false`.
8881    /// Whether multi-region access points (MRAP) should be disabled.
8882    pub fn set_disable_multi_region_access_points(mut self, param: Option<bool>) -> Self {
8883        self.disable_multi_region_access_points = param;
8884        self
8885    }
8886    /// Sets the value for use_arn_region
8887    ///
8888    /// 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.
8889    pub fn use_arn_region(mut self, value: impl Into<bool>) -> Self {
8890        self.use_arn_region = Some(value.into());
8891        self
8892    }
8893
8894    /// Sets the value for use_arn_region
8895    ///
8896    /// 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.
8897    pub fn set_use_arn_region(mut self, param: Option<bool>) -> Self {
8898        self.use_arn_region = param;
8899        self
8900    }
8901    /// Sets the value for use_s3_express_control_endpoint
8902    ///
8903    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
8904    pub fn use_s3_express_control_endpoint(mut self, value: impl Into<bool>) -> Self {
8905        self.use_s3_express_control_endpoint = Some(value.into());
8906        self
8907    }
8908
8909    /// Sets the value for use_s3_express_control_endpoint
8910    ///
8911    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
8912    pub fn set_use_s3_express_control_endpoint(mut self, param: Option<bool>) -> Self {
8913        self.use_s3_express_control_endpoint = param;
8914        self
8915    }
8916    /// Sets the value for disable_s3_express_session_auth
8917    ///
8918    /// Parameter to indicate whether S3Express session auth should be disabled
8919    pub fn disable_s3_express_session_auth(mut self, value: impl Into<bool>) -> Self {
8920        self.disable_s3_express_session_auth = Some(value.into());
8921        self
8922    }
8923
8924    /// Sets the value for disable_s3_express_session_auth
8925    ///
8926    /// Parameter to indicate whether S3Express session auth should be disabled
8927    pub fn set_disable_s3_express_session_auth(mut self, param: Option<bool>) -> Self {
8928        self.disable_s3_express_session_auth = param;
8929        self
8930    }
8931}
8932
8933/// An error that occurred during endpoint resolution
8934#[derive(Debug)]
8935pub struct InvalidParams {
8936    field: std::borrow::Cow<'static, str>,
8937}
8938
8939impl InvalidParams {
8940    #[allow(dead_code)]
8941    fn missing(field: &'static str) -> Self {
8942        Self { field: field.into() }
8943    }
8944}
8945
8946impl std::fmt::Display for InvalidParams {
8947    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8948        write!(f, "a required field was missing: `{}`", self.field)
8949    }
8950}
8951
8952impl std::error::Error for InvalidParams {}
8953
8954mod internals;
aws_sdk_s3/config/endpoint.rs

aws_sdk_s3/config/
endpoint.rs
