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 zone name
7681    #[test]
7682    fn test_275() {
7683        let params = crate::config::endpoint::Params::builder()
7684            .region("us-east-1".to_string())
7685            .bucket("mybucket--abcd-ab1--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--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com");
7695        assert_eq!(
7696            endpoint,
7697            ::aws_smithy_types::endpoint::Endpoint::builder()
7698                .url("https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.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 zone names (13 chars)
7716    #[test]
7717    fn test_276() {
7718        let params = crate::config::endpoint::Params::builder()
7719            .region("us-west-2".to_string())
7720            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
7721            .use_fips(false)
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 =
7730            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
7731        assert_eq!(
7732            endpoint,
7733            ::aws_smithy_types::endpoint::Endpoint::builder()
7734                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
7735                .property(
7736                    "authSchemes",
7737                    vec![::aws_smithy_types::Document::from({
7738                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7739                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7740                        out.insert("signingName".to_string(), "s3express".to_string().into());
7741                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7742                        out.insert("disableDoubleEncoding".to_string(), true.into());
7743                        out
7744                    })]
7745                )
7746                .property("backend", "S3Express".to_string())
7747                .build()
7748        );
7749    }
7750
7751    /// Data Plane with medium zone names (14 chars)
7752    #[test]
7753    fn test_277() {
7754        let params = crate::config::endpoint::Params::builder()
7755            .region("us-west-2".to_string())
7756            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
7757            .use_fips(false)
7758            .use_dual_stack(false)
7759            .accelerate(false)
7760            .use_s3_express_control_endpoint(false)
7761            .build()
7762            .expect("invalid params");
7763        let resolver = crate::config::endpoint::DefaultResolver::new();
7764        let endpoint = resolver.resolve_endpoint(&params);
7765        let endpoint =
7766            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
7767        assert_eq!(
7768            endpoint,
7769            ::aws_smithy_types::endpoint::Endpoint::builder()
7770                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
7771                .property(
7772                    "authSchemes",
7773                    vec![::aws_smithy_types::Document::from({
7774                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7775                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7776                        out.insert("signingName".to_string(), "s3express".to_string().into());
7777                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7778                        out.insert("disableDoubleEncoding".to_string(), true.into());
7779                        out
7780                    })]
7781                )
7782                .property("backend", "S3Express".to_string())
7783                .build()
7784        );
7785    }
7786
7787    /// Data Plane with long zone names (20 chars)
7788    #[test]
7789    fn test_278() {
7790        let params = crate::config::endpoint::Params::builder()
7791            .region("us-west-2".to_string())
7792            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
7793            .use_fips(false)
7794            .use_dual_stack(false)
7795            .accelerate(false)
7796            .use_s3_express_control_endpoint(false)
7797            .build()
7798            .expect("invalid params");
7799        let resolver = crate::config::endpoint::DefaultResolver::new();
7800        let endpoint = resolver.resolve_endpoint(&params);
7801        let endpoint = endpoint
7802            .expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com");
7803        assert_eq!(
7804            endpoint,
7805            ::aws_smithy_types::endpoint::Endpoint::builder()
7806                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
7807                .property(
7808                    "authSchemes",
7809                    vec![::aws_smithy_types::Document::from({
7810                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7811                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7812                        out.insert("signingName".to_string(), "s3express".to_string().into());
7813                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7814                        out.insert("disableDoubleEncoding".to_string(), true.into());
7815                        out
7816                    })]
7817                )
7818                .property("backend", "S3Express".to_string())
7819                .build()
7820        );
7821    }
7822
7823    /// Data Plane with short zone fips
7824    #[test]
7825    fn test_279() {
7826        let params = crate::config::endpoint::Params::builder()
7827            .region("us-east-1".to_string())
7828            .bucket("mybucket--test-ab1--x-s3".to_string())
7829            .use_fips(true)
7830            .use_dual_stack(false)
7831            .accelerate(false)
7832            .use_s3_express_control_endpoint(false)
7833            .build()
7834            .expect("invalid params");
7835        let resolver = crate::config::endpoint::DefaultResolver::new();
7836        let endpoint = resolver.resolve_endpoint(&params);
7837        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test-ab1--x-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com");
7838        assert_eq!(
7839            endpoint,
7840            ::aws_smithy_types::endpoint::Endpoint::builder()
7841                .url("https://mybucket--test-ab1--x-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com")
7842                .property(
7843                    "authSchemes",
7844                    vec![::aws_smithy_types::Document::from({
7845                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7846                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7847                        out.insert("signingName".to_string(), "s3express".to_string().into());
7848                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
7849                        out.insert("disableDoubleEncoding".to_string(), true.into());
7850                        out
7851                    })]
7852                )
7853                .property("backend", "S3Express".to_string())
7854                .build()
7855        );
7856    }
7857
7858    /// Data Plane with short zone (13 chars) fips
7859    #[test]
7860    fn test_280() {
7861        let params = crate::config::endpoint::Params::builder()
7862            .region("us-west-2".to_string())
7863            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
7864            .use_fips(true)
7865            .use_dual_stack(false)
7866            .accelerate(false)
7867            .use_s3_express_control_endpoint(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 =
7873            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
7874        assert_eq!(
7875            endpoint,
7876            ::aws_smithy_types::endpoint::Endpoint::builder()
7877                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
7878                .property(
7879                    "authSchemes",
7880                    vec![::aws_smithy_types::Document::from({
7881                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7882                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7883                        out.insert("signingName".to_string(), "s3express".to_string().into());
7884                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7885                        out.insert("disableDoubleEncoding".to_string(), true.into());
7886                        out
7887                    })]
7888                )
7889                .property("backend", "S3Express".to_string())
7890                .build()
7891        );
7892    }
7893
7894    /// Data Plane with medium zone (14 chars) fips
7895    #[test]
7896    fn test_281() {
7897        let params = crate::config::endpoint::Params::builder()
7898            .region("us-west-2".to_string())
7899            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
7900            .use_fips(true)
7901            .use_dual_stack(false)
7902            .accelerate(false)
7903            .use_s3_express_control_endpoint(false)
7904            .build()
7905            .expect("invalid params");
7906        let resolver = crate::config::endpoint::DefaultResolver::new();
7907        let endpoint = resolver.resolve_endpoint(&params);
7908        let endpoint =
7909            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
7910        assert_eq!(
7911            endpoint,
7912            ::aws_smithy_types::endpoint::Endpoint::builder()
7913                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
7914                .property(
7915                    "authSchemes",
7916                    vec![::aws_smithy_types::Document::from({
7917                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7918                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7919                        out.insert("signingName".to_string(), "s3express".to_string().into());
7920                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7921                        out.insert("disableDoubleEncoding".to_string(), true.into());
7922                        out
7923                    })]
7924                )
7925                .property("backend", "S3Express".to_string())
7926                .build()
7927        );
7928    }
7929
7930    /// Data Plane with long zone (20 chars) fips
7931    #[test]
7932    fn test_282() {
7933        let params = crate::config::endpoint::Params::builder()
7934            .region("us-west-2".to_string())
7935            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
7936            .use_fips(true)
7937            .use_dual_stack(false)
7938            .accelerate(false)
7939            .use_s3_express_control_endpoint(false)
7940            .build()
7941            .expect("invalid params");
7942        let resolver = crate::config::endpoint::DefaultResolver::new();
7943        let endpoint = resolver.resolve_endpoint(&params);
7944        let endpoint = endpoint.expect(
7945            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
7946        );
7947        assert_eq!(
7948            endpoint,
7949            ::aws_smithy_types::endpoint::Endpoint::builder()
7950                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
7951                .property(
7952                    "authSchemes",
7953                    vec![::aws_smithy_types::Document::from({
7954                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7955                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7956                        out.insert("signingName".to_string(), "s3express".to_string().into());
7957                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7958                        out.insert("disableDoubleEncoding".to_string(), true.into());
7959                        out
7960                    })]
7961                )
7962                .property("backend", "S3Express".to_string())
7963                .build()
7964        );
7965    }
7966
7967    /// Data Plane with long AZ
7968    #[test]
7969    fn test_283() {
7970        let params = crate::config::endpoint::Params::builder()
7971            .region("us-west-2".to_string())
7972            .bucket("mybucket--test1-az1--x-s3".to_string())
7973            .use_fips(false)
7974            .use_dual_stack(false)
7975            .accelerate(false)
7976            .use_s3_express_control_endpoint(false)
7977            .build()
7978            .expect("invalid params");
7979        let resolver = crate::config::endpoint::DefaultResolver::new();
7980        let endpoint = resolver.resolve_endpoint(&params);
7981        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com");
7982        assert_eq!(
7983            endpoint,
7984            ::aws_smithy_types::endpoint::Endpoint::builder()
7985                .url("https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com")
7986                .property(
7987                    "authSchemes",
7988                    vec![::aws_smithy_types::Document::from({
7989                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
7990                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
7991                        out.insert("signingName".to_string(), "s3express".to_string().into());
7992                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
7993                        out.insert("disableDoubleEncoding".to_string(), true.into());
7994                        out
7995                    })]
7996                )
7997                .property("backend", "S3Express".to_string())
7998                .build()
7999        );
8000    }
8001
8002    /// Data Plane with long AZ fips
8003    #[test]
8004    fn test_284() {
8005        let params = crate::config::endpoint::Params::builder()
8006            .region("us-west-2".to_string())
8007            .bucket("mybucket--test1-az1--x-s3".to_string())
8008            .use_fips(true)
8009            .use_dual_stack(false)
8010            .accelerate(false)
8011            .use_s3_express_control_endpoint(false)
8012            .build()
8013            .expect("invalid params");
8014        let resolver = crate::config::endpoint::DefaultResolver::new();
8015        let endpoint = resolver.resolve_endpoint(&params);
8016        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
8017        assert_eq!(
8018            endpoint,
8019            ::aws_smithy_types::endpoint::Endpoint::builder()
8020                .url("https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
8021                .property(
8022                    "authSchemes",
8023                    vec![::aws_smithy_types::Document::from({
8024                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8025                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8026                        out.insert("signingName".to_string(), "s3express".to_string().into());
8027                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8028                        out.insert("disableDoubleEncoding".to_string(), true.into());
8029                        out
8030                    })]
8031                )
8032                .property("backend", "S3Express".to_string())
8033                .build()
8034        );
8035    }
8036
8037    /// Control plane with short AZ bucket
8038    #[test]
8039    fn test_285() {
8040        let params = crate::config::endpoint::Params::builder()
8041            .region("us-east-1".to_string())
8042            .bucket("mybucket--test-ab1--x-s3".to_string())
8043            .use_fips(false)
8044            .use_dual_stack(false)
8045            .accelerate(false)
8046            .use_s3_express_control_endpoint(true)
8047            .disable_s3_express_session_auth(false)
8048            .build()
8049            .expect("invalid params");
8050        let resolver = crate::config::endpoint::DefaultResolver::new();
8051        let endpoint = resolver.resolve_endpoint(&params);
8052        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
8053        assert_eq!(
8054            endpoint,
8055            ::aws_smithy_types::endpoint::Endpoint::builder()
8056                .url("https://s3express-control.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
8057                .property(
8058                    "authSchemes",
8059                    vec![::aws_smithy_types::Document::from({
8060                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8061                        out.insert("name".to_string(), "sigv4".to_string().into());
8062                        out.insert("signingName".to_string(), "s3express".to_string().into());
8063                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
8064                        out.insert("disableDoubleEncoding".to_string(), true.into());
8065                        out
8066                    })]
8067                )
8068                .property("backend", "S3Express".to_string())
8069                .build()
8070        );
8071    }
8072
8073    /// Control plane with short AZ bucket and fips
8074    #[test]
8075    fn test_286() {
8076        let params = crate::config::endpoint::Params::builder()
8077            .region("us-east-1".to_string())
8078            .bucket("mybucket--test-ab1--x-s3".to_string())
8079            .use_fips(true)
8080            .use_dual_stack(false)
8081            .accelerate(false)
8082            .use_s3_express_control_endpoint(true)
8083            .disable_s3_express_session_auth(false)
8084            .build()
8085            .expect("invalid params");
8086        let resolver = crate::config::endpoint::DefaultResolver::new();
8087        let endpoint = resolver.resolve_endpoint(&params);
8088        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
8089        assert_eq!(
8090            endpoint,
8091            ::aws_smithy_types::endpoint::Endpoint::builder()
8092                .url("https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
8093                .property(
8094                    "authSchemes",
8095                    vec![::aws_smithy_types::Document::from({
8096                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8097                        out.insert("name".to_string(), "sigv4".to_string().into());
8098                        out.insert("signingName".to_string(), "s3express".to_string().into());
8099                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
8100                        out.insert("disableDoubleEncoding".to_string(), true.into());
8101                        out
8102                    })]
8103                )
8104                .property("backend", "S3Express".to_string())
8105                .build()
8106        );
8107    }
8108
8109    /// Control plane without bucket
8110    #[test]
8111    fn test_287() {
8112        let params = crate::config::endpoint::Params::builder()
8113            .region("us-east-1".to_string())
8114            .use_fips(false)
8115            .use_dual_stack(false)
8116            .accelerate(false)
8117            .use_s3_express_control_endpoint(true)
8118            .disable_s3_express_session_auth(false)
8119            .build()
8120            .expect("invalid params");
8121        let resolver = crate::config::endpoint::DefaultResolver::new();
8122        let endpoint = resolver.resolve_endpoint(&params);
8123        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com");
8124        assert_eq!(
8125            endpoint,
8126            ::aws_smithy_types::endpoint::Endpoint::builder()
8127                .url("https://s3express-control.us-east-1.amazonaws.com")
8128                .property(
8129                    "authSchemes",
8130                    vec![::aws_smithy_types::Document::from({
8131                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8132                        out.insert("name".to_string(), "sigv4".to_string().into());
8133                        out.insert("signingName".to_string(), "s3express".to_string().into());
8134                        out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
8135                        out.insert("disableDoubleEncoding".to_string(), true.into());
8136                        out
8137                    })]
8138                )
8139                .property("backend", "S3Express".to_string())
8140                .build()
8141        );
8142    }
8143
8144    /// Control plane without bucket and fips
8145    #[test]
8146    fn test_288() {
8147        let params = crate::config::endpoint::Params::builder()
8148            .region("us-east-1".to_string())
8149            .use_fips(true)
8150            .use_dual_stack(false)
8151            .accelerate(false)
8152            .use_s3_express_control_endpoint(true)
8153            .disable_s3_express_session_auth(false)
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://s3express-control-fips.us-east-1.amazonaws.com");
8159        assert_eq!(
8160            endpoint,
8161            ::aws_smithy_types::endpoint::Endpoint::builder()
8162                .url("https://s3express-control-fips.us-east-1.amazonaws.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-east-1".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 sigv4 auth with short AZ
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            .disable_s3_express_session_auth(true)
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://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com");
8194        assert_eq!(
8195            endpoint,
8196            ::aws_smithy_types::endpoint::Endpoint::builder()
8197                .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com")
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".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    /// Data Plane sigv4 auth with short zone (13 chars)
8215    #[test]
8216    fn test_290() {
8217        let params = crate::config::endpoint::Params::builder()
8218            .region("us-west-2".to_string())
8219            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
8220            .use_fips(false)
8221            .use_dual_stack(false)
8222            .accelerate(false)
8223            .disable_s3_express_session_auth(true)
8224            .build()
8225            .expect("invalid params");
8226        let resolver = crate::config::endpoint::DefaultResolver::new();
8227        let endpoint = resolver.resolve_endpoint(&params);
8228        let endpoint =
8229            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
8230        assert_eq!(
8231            endpoint,
8232            ::aws_smithy_types::endpoint::Endpoint::builder()
8233                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
8234                .property(
8235                    "authSchemes",
8236                    vec![::aws_smithy_types::Document::from({
8237                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8238                        out.insert("name".to_string(), "sigv4".to_string().into());
8239                        out.insert("signingName".to_string(), "s3express".to_string().into());
8240                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8241                        out.insert("disableDoubleEncoding".to_string(), true.into());
8242                        out
8243                    })]
8244                )
8245                .property("backend", "S3Express".to_string())
8246                .build()
8247        );
8248    }
8249
8250    /// Data Plane sigv4 auth with short AZ fips
8251    #[test]
8252    fn test_291() {
8253        let params = crate::config::endpoint::Params::builder()
8254            .region("us-west-2".to_string())
8255            .bucket("mybucket--usw2-az1--x-s3".to_string())
8256            .use_fips(true)
8257            .use_dual_stack(false)
8258            .accelerate(false)
8259            .disable_s3_express_session_auth(true)
8260            .build()
8261            .expect("invalid params");
8262        let resolver = crate::config::endpoint::DefaultResolver::new();
8263        let endpoint = resolver.resolve_endpoint(&params);
8264        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com");
8265        assert_eq!(
8266            endpoint,
8267            ::aws_smithy_types::endpoint::Endpoint::builder()
8268                .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com")
8269                .property(
8270                    "authSchemes",
8271                    vec![::aws_smithy_types::Document::from({
8272                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8273                        out.insert("name".to_string(), "sigv4".to_string().into());
8274                        out.insert("signingName".to_string(), "s3express".to_string().into());
8275                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8276                        out.insert("disableDoubleEncoding".to_string(), true.into());
8277                        out
8278                    })]
8279                )
8280                .property("backend", "S3Express".to_string())
8281                .build()
8282        );
8283    }
8284
8285    /// Data Plane sigv4 auth with short zone (13 chars) fips
8286    #[test]
8287    fn test_292() {
8288        let params = crate::config::endpoint::Params::builder()
8289            .region("us-west-2".to_string())
8290            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
8291            .use_fips(true)
8292            .use_dual_stack(false)
8293            .accelerate(false)
8294            .disable_s3_express_session_auth(true)
8295            .build()
8296            .expect("invalid params");
8297        let resolver = crate::config::endpoint::DefaultResolver::new();
8298        let endpoint = resolver.resolve_endpoint(&params);
8299        let endpoint =
8300            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
8301        assert_eq!(
8302            endpoint,
8303            ::aws_smithy_types::endpoint::Endpoint::builder()
8304                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
8305                .property(
8306                    "authSchemes",
8307                    vec![::aws_smithy_types::Document::from({
8308                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8309                        out.insert("name".to_string(), "sigv4".to_string().into());
8310                        out.insert("signingName".to_string(), "s3express".to_string().into());
8311                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8312                        out.insert("disableDoubleEncoding".to_string(), true.into());
8313                        out
8314                    })]
8315                )
8316                .property("backend", "S3Express".to_string())
8317                .build()
8318        );
8319    }
8320
8321    /// Data Plane sigv4 auth with long AZ
8322    #[test]
8323    fn test_293() {
8324        let params = crate::config::endpoint::Params::builder()
8325            .region("us-west-2".to_string())
8326            .bucket("mybucket--test1-az1--x-s3".to_string())
8327            .use_fips(false)
8328            .use_dual_stack(false)
8329            .accelerate(false)
8330            .use_s3_express_control_endpoint(false)
8331            .disable_s3_express_session_auth(true)
8332            .build()
8333            .expect("invalid params");
8334        let resolver = crate::config::endpoint::DefaultResolver::new();
8335        let endpoint = resolver.resolve_endpoint(&params);
8336        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com");
8337        assert_eq!(
8338            endpoint,
8339            ::aws_smithy_types::endpoint::Endpoint::builder()
8340                .url("https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com")
8341                .property(
8342                    "authSchemes",
8343                    vec![::aws_smithy_types::Document::from({
8344                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8345                        out.insert("name".to_string(), "sigv4".to_string().into());
8346                        out.insert("signingName".to_string(), "s3express".to_string().into());
8347                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8348                        out.insert("disableDoubleEncoding".to_string(), true.into());
8349                        out
8350                    })]
8351                )
8352                .property("backend", "S3Express".to_string())
8353                .build()
8354        );
8355    }
8356
8357    /// Data Plane sigv4 auth with medium zone(14 chars)
8358    #[test]
8359    fn test_294() {
8360        let params = crate::config::endpoint::Params::builder()
8361            .region("us-west-2".to_string())
8362            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
8363            .use_fips(false)
8364            .use_dual_stack(false)
8365            .accelerate(false)
8366            .use_s3_express_control_endpoint(false)
8367            .disable_s3_express_session_auth(true)
8368            .build()
8369            .expect("invalid params");
8370        let resolver = crate::config::endpoint::DefaultResolver::new();
8371        let endpoint = resolver.resolve_endpoint(&params);
8372        let endpoint =
8373            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
8374        assert_eq!(
8375            endpoint,
8376            ::aws_smithy_types::endpoint::Endpoint::builder()
8377                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
8378                .property(
8379                    "authSchemes",
8380                    vec![::aws_smithy_types::Document::from({
8381                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8382                        out.insert("name".to_string(), "sigv4".to_string().into());
8383                        out.insert("signingName".to_string(), "s3express".to_string().into());
8384                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8385                        out.insert("disableDoubleEncoding".to_string(), true.into());
8386                        out
8387                    })]
8388                )
8389                .property("backend", "S3Express".to_string())
8390                .build()
8391        );
8392    }
8393
8394    /// Data Plane sigv4 auth with long zone(20 chars)
8395    #[test]
8396    fn test_295() {
8397        let params = crate::config::endpoint::Params::builder()
8398            .region("us-west-2".to_string())
8399            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
8400            .use_fips(false)
8401            .use_dual_stack(false)
8402            .accelerate(false)
8403            .use_s3_express_control_endpoint(false)
8404            .disable_s3_express_session_auth(true)
8405            .build()
8406            .expect("invalid params");
8407        let resolver = crate::config::endpoint::DefaultResolver::new();
8408        let endpoint = resolver.resolve_endpoint(&params);
8409        let endpoint = endpoint
8410            .expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com");
8411        assert_eq!(
8412            endpoint,
8413            ::aws_smithy_types::endpoint::Endpoint::builder()
8414                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
8415                .property(
8416                    "authSchemes",
8417                    vec![::aws_smithy_types::Document::from({
8418                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8419                        out.insert("name".to_string(), "sigv4".to_string().into());
8420                        out.insert("signingName".to_string(), "s3express".to_string().into());
8421                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8422                        out.insert("disableDoubleEncoding".to_string(), true.into());
8423                        out
8424                    })]
8425                )
8426                .property("backend", "S3Express".to_string())
8427                .build()
8428        );
8429    }
8430
8431    /// Data Plane sigv4 auth with long AZ fips
8432    #[test]
8433    fn test_296() {
8434        let params = crate::config::endpoint::Params::builder()
8435            .region("us-west-2".to_string())
8436            .bucket("mybucket--test1-az1--x-s3".to_string())
8437            .use_fips(true)
8438            .use_dual_stack(false)
8439            .accelerate(false)
8440            .use_s3_express_control_endpoint(false)
8441            .disable_s3_express_session_auth(true)
8442            .build()
8443            .expect("invalid params");
8444        let resolver = crate::config::endpoint::DefaultResolver::new();
8445        let endpoint = resolver.resolve_endpoint(&params);
8446        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
8447        assert_eq!(
8448            endpoint,
8449            ::aws_smithy_types::endpoint::Endpoint::builder()
8450                .url("https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
8451                .property(
8452                    "authSchemes",
8453                    vec![::aws_smithy_types::Document::from({
8454                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8455                        out.insert("name".to_string(), "sigv4".to_string().into());
8456                        out.insert("signingName".to_string(), "s3express".to_string().into());
8457                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8458                        out.insert("disableDoubleEncoding".to_string(), true.into());
8459                        out
8460                    })]
8461                )
8462                .property("backend", "S3Express".to_string())
8463                .build()
8464        );
8465    }
8466
8467    /// Data Plane sigv4 auth with medium zone (14 chars) fips
8468    #[test]
8469    fn test_297() {
8470        let params = crate::config::endpoint::Params::builder()
8471            .region("us-west-2".to_string())
8472            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
8473            .use_fips(true)
8474            .use_dual_stack(false)
8475            .accelerate(false)
8476            .use_s3_express_control_endpoint(false)
8477            .disable_s3_express_session_auth(true)
8478            .build()
8479            .expect("invalid params");
8480        let resolver = crate::config::endpoint::DefaultResolver::new();
8481        let endpoint = resolver.resolve_endpoint(&params);
8482        let endpoint =
8483            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
8484        assert_eq!(
8485            endpoint,
8486            ::aws_smithy_types::endpoint::Endpoint::builder()
8487                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
8488                .property(
8489                    "authSchemes",
8490                    vec![::aws_smithy_types::Document::from({
8491                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8492                        out.insert("name".to_string(), "sigv4".to_string().into());
8493                        out.insert("signingName".to_string(), "s3express".to_string().into());
8494                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8495                        out.insert("disableDoubleEncoding".to_string(), true.into());
8496                        out
8497                    })]
8498                )
8499                .property("backend", "S3Express".to_string())
8500                .build()
8501        );
8502    }
8503
8504    /// Data Plane sigv4 auth with long zone (20 chars) fips
8505    #[test]
8506    fn test_298() {
8507        let params = crate::config::endpoint::Params::builder()
8508            .region("us-west-2".to_string())
8509            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
8510            .use_fips(true)
8511            .use_dual_stack(false)
8512            .accelerate(false)
8513            .use_s3_express_control_endpoint(false)
8514            .disable_s3_express_session_auth(true)
8515            .build()
8516            .expect("invalid params");
8517        let resolver = crate::config::endpoint::DefaultResolver::new();
8518        let endpoint = resolver.resolve_endpoint(&params);
8519        let endpoint = endpoint.expect(
8520            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
8521        );
8522        assert_eq!(
8523            endpoint,
8524            ::aws_smithy_types::endpoint::Endpoint::builder()
8525                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
8526                .property(
8527                    "authSchemes",
8528                    vec![::aws_smithy_types::Document::from({
8529                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8530                        out.insert("name".to_string(), "sigv4".to_string().into());
8531                        out.insert("signingName".to_string(), "s3express".to_string().into());
8532                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8533                        out.insert("disableDoubleEncoding".to_string(), true.into());
8534                        out
8535                    })]
8536                )
8537                .property("backend", "S3Express".to_string())
8538                .build()
8539        );
8540    }
8541
8542    /// Control Plane host override
8543    #[test]
8544    fn test_299() {
8545        let params = crate::config::endpoint::Params::builder()
8546            .region("us-west-2".to_string())
8547            .bucket("mybucket--usw2-az1--x-s3".to_string())
8548            .use_fips(false)
8549            .use_dual_stack(false)
8550            .accelerate(false)
8551            .use_s3_express_control_endpoint(true)
8552            .disable_s3_express_session_auth(true)
8553            .endpoint("https://custom.com".to_string())
8554            .build()
8555            .expect("invalid params");
8556        let resolver = crate::config::endpoint::DefaultResolver::new();
8557        let endpoint = resolver.resolve_endpoint(&params);
8558        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
8559        assert_eq!(
8560            endpoint,
8561            ::aws_smithy_types::endpoint::Endpoint::builder()
8562                .url("https://mybucket--usw2-az1--x-s3.custom.com")
8563                .property(
8564                    "authSchemes",
8565                    vec![::aws_smithy_types::Document::from({
8566                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8567                        out.insert("name".to_string(), "sigv4".to_string().into());
8568                        out.insert("signingName".to_string(), "s3express".to_string().into());
8569                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8570                        out.insert("disableDoubleEncoding".to_string(), true.into());
8571                        out
8572                    })]
8573                )
8574                .property("backend", "S3Express".to_string())
8575                .build()
8576        );
8577    }
8578
8579    /// Control Plane host override no bucket
8580    #[test]
8581    fn test_300() {
8582        let params = crate::config::endpoint::Params::builder()
8583            .region("us-west-2".to_string())
8584            .use_fips(false)
8585            .use_dual_stack(false)
8586            .accelerate(false)
8587            .use_s3_express_control_endpoint(true)
8588            .disable_s3_express_session_auth(true)
8589            .endpoint("https://custom.com".to_string())
8590            .build()
8591            .expect("invalid params");
8592        let resolver = crate::config::endpoint::DefaultResolver::new();
8593        let endpoint = resolver.resolve_endpoint(&params);
8594        let endpoint = endpoint.expect("Expected valid endpoint: https://custom.com");
8595        assert_eq!(
8596            endpoint,
8597            ::aws_smithy_types::endpoint::Endpoint::builder()
8598                .url("https://custom.com")
8599                .property(
8600                    "authSchemes",
8601                    vec![::aws_smithy_types::Document::from({
8602                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8603                        out.insert("name".to_string(), "sigv4".to_string().into());
8604                        out.insert("signingName".to_string(), "s3express".to_string().into());
8605                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8606                        out.insert("disableDoubleEncoding".to_string(), true.into());
8607                        out
8608                    })]
8609                )
8610                .property("backend", "S3Express".to_string())
8611                .build()
8612        );
8613    }
8614
8615    /// Data plane host override non virtual session auth
8616    #[test]
8617    fn test_301() {
8618        let params = crate::config::endpoint::Params::builder()
8619            .region("us-west-2".to_string())
8620            .bucket("mybucket--usw2-az1--x-s3".to_string())
8621            .use_fips(false)
8622            .use_dual_stack(false)
8623            .accelerate(false)
8624            .endpoint("https://10.0.0.1".to_string())
8625            .build()
8626            .expect("invalid params");
8627        let resolver = crate::config::endpoint::DefaultResolver::new();
8628        let endpoint = resolver.resolve_endpoint(&params);
8629        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
8630        assert_eq!(
8631            endpoint,
8632            ::aws_smithy_types::endpoint::Endpoint::builder()
8633                .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
8634                .property(
8635                    "authSchemes",
8636                    vec![::aws_smithy_types::Document::from({
8637                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8638                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8639                        out.insert("signingName".to_string(), "s3express".to_string().into());
8640                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8641                        out.insert("disableDoubleEncoding".to_string(), true.into());
8642                        out
8643                    })]
8644                )
8645                .property("backend", "S3Express".to_string())
8646                .build()
8647        );
8648    }
8649
8650    /// Control Plane host override ip
8651    #[test]
8652    fn test_302() {
8653        let params = crate::config::endpoint::Params::builder()
8654            .region("us-west-2".to_string())
8655            .bucket("mybucket--usw2-az1--x-s3".to_string())
8656            .use_fips(false)
8657            .use_dual_stack(false)
8658            .accelerate(false)
8659            .use_s3_express_control_endpoint(true)
8660            .disable_s3_express_session_auth(true)
8661            .endpoint("https://10.0.0.1".to_string())
8662            .build()
8663            .expect("invalid params");
8664        let resolver = crate::config::endpoint::DefaultResolver::new();
8665        let endpoint = resolver.resolve_endpoint(&params);
8666        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
8667        assert_eq!(
8668            endpoint,
8669            ::aws_smithy_types::endpoint::Endpoint::builder()
8670                .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
8671                .property(
8672                    "authSchemes",
8673                    vec![::aws_smithy_types::Document::from({
8674                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8675                        out.insert("name".to_string(), "sigv4".to_string().into());
8676                        out.insert("signingName".to_string(), "s3express".to_string().into());
8677                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8678                        out.insert("disableDoubleEncoding".to_string(), true.into());
8679                        out
8680                    })]
8681                )
8682                .property("backend", "S3Express".to_string())
8683                .build()
8684        );
8685    }
8686
8687    /// Data plane host override
8688    #[test]
8689    fn test_303() {
8690        let params = crate::config::endpoint::Params::builder()
8691            .region("us-west-2".to_string())
8692            .bucket("mybucket--usw2-az1--x-s3".to_string())
8693            .use_fips(false)
8694            .use_dual_stack(false)
8695            .accelerate(false)
8696            .endpoint("https://custom.com".to_string())
8697            .build()
8698            .expect("invalid params");
8699        let resolver = crate::config::endpoint::DefaultResolver::new();
8700        let endpoint = resolver.resolve_endpoint(&params);
8701        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
8702        assert_eq!(
8703            endpoint,
8704            ::aws_smithy_types::endpoint::Endpoint::builder()
8705                .url("https://mybucket--usw2-az1--x-s3.custom.com")
8706                .property(
8707                    "authSchemes",
8708                    vec![::aws_smithy_types::Document::from({
8709                        let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
8710                        out.insert("name".to_string(), "sigv4-s3express".to_string().into());
8711                        out.insert("signingName".to_string(), "s3express".to_string().into());
8712                        out.insert("signingRegion".to_string(), "us-west-2".to_string().into());
8713                        out.insert("disableDoubleEncoding".to_string(), true.into());
8714                        out
8715                    })]
8716                )
8717                .property("backend", "S3Express".to_string())
8718                .build()
8719        );
8720    }
8721
8722    /// bad format error
8723    #[test]
8724    fn test_304() {
8725        let params = crate::config::endpoint::Params::builder()
8726            .region("us-east-1".to_string())
8727            .bucket("mybucket--usaz1--x-s3".to_string())
8728            .use_fips(false)
8729            .use_dual_stack(false)
8730            .accelerate(false)
8731            .use_s3_express_control_endpoint(false)
8732            .build()
8733            .expect("invalid params");
8734        let resolver = crate::config::endpoint::DefaultResolver::new();
8735        let endpoint = resolver.resolve_endpoint(&params);
8736        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad format error]");
8737        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
8738    }
8739
8740    /// bad format error no session auth
8741    #[test]
8742    fn test_305() {
8743        let params = crate::config::endpoint::Params::builder()
8744            .region("us-east-1".to_string())
8745            .bucket("mybucket--usaz1--x-s3".to_string())
8746            .use_fips(false)
8747            .use_dual_stack(false)
8748            .accelerate(false)
8749            .use_s3_express_control_endpoint(false)
8750            .disable_s3_express_session_auth(true)
8751            .build()
8752            .expect("invalid params");
8753        let resolver = crate::config::endpoint::DefaultResolver::new();
8754        let endpoint = resolver.resolve_endpoint(&params);
8755        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad format error no session auth]");
8756        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
8757    }
8758
8759    /// dual-stack error
8760    #[test]
8761    fn test_306() {
8762        let params = crate::config::endpoint::Params::builder()
8763            .region("us-east-1".to_string())
8764            .bucket("mybucket--test-ab1--x-s3".to_string())
8765            .use_fips(false)
8766            .use_dual_stack(true)
8767            .accelerate(false)
8768            .use_s3_express_control_endpoint(false)
8769            .build()
8770            .expect("invalid params");
8771        let resolver = crate::config::endpoint::DefaultResolver::new();
8772        let endpoint = resolver.resolve_endpoint(&params);
8773        let error = endpoint.expect_err("expected error: S3Express does not support Dual-stack. [dual-stack error]");
8774        assert_eq!(format!("{}", error), "S3Express does not support Dual-stack.")
8775    }
8776
8777    /// accelerate error
8778    #[test]
8779    fn test_307() {
8780        let params = crate::config::endpoint::Params::builder()
8781            .region("us-east-1".to_string())
8782            .bucket("mybucket--test-ab1--x-s3".to_string())
8783            .use_fips(false)
8784            .use_dual_stack(false)
8785            .accelerate(true)
8786            .use_s3_express_control_endpoint(false)
8787            .build()
8788            .expect("invalid params");
8789        let resolver = crate::config::endpoint::DefaultResolver::new();
8790        let endpoint = resolver.resolve_endpoint(&params);
8791        let error = endpoint.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error]");
8792        assert_eq!(format!("{}", error), "S3Express does not support S3 Accelerate.")
8793    }
8794
8795    /// Data plane bucket format error
8796    #[test]
8797    fn test_308() {
8798        let params = crate::config::endpoint::Params::builder()
8799            .region("us-east-1".to_string())
8800            .bucket("my.bucket--test-ab1--x-s3".to_string())
8801            .use_fips(false)
8802            .use_dual_stack(false)
8803            .accelerate(false)
8804            .use_s3_express_control_endpoint(false)
8805            .build()
8806            .expect("invalid params");
8807        let resolver = crate::config::endpoint::DefaultResolver::new();
8808        let endpoint = resolver.resolve_endpoint(&params);
8809        let error =
8810            endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane bucket format error]");
8811        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8812    }
8813
8814    /// host override data plane bucket error session auth
8815    #[test]
8816    fn test_309() {
8817        let params = crate::config::endpoint::Params::builder()
8818            .region("us-west-2".to_string())
8819            .bucket("my.bucket--usw2-az1--x-s3".to_string())
8820            .use_fips(false)
8821            .use_dual_stack(false)
8822            .accelerate(false)
8823            .endpoint("https://custom.com".to_string())
8824            .build()
8825            .expect("invalid params");
8826        let resolver = crate::config::endpoint::DefaultResolver::new();
8827        let endpoint = resolver.resolve_endpoint(&params);
8828        let error = endpoint.expect_err(
8829            "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error session auth]",
8830        );
8831        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8832    }
8833
8834    /// host override data plane bucket error
8835    #[test]
8836    fn test_310() {
8837        let params = crate::config::endpoint::Params::builder()
8838            .region("us-west-2".to_string())
8839            .bucket("my.bucket--usw2-az1--x-s3".to_string())
8840            .use_fips(false)
8841            .use_dual_stack(false)
8842            .accelerate(false)
8843            .endpoint("https://custom.com".to_string())
8844            .disable_s3_express_session_auth(true)
8845            .build()
8846            .expect("invalid params");
8847        let resolver = crate::config::endpoint::DefaultResolver::new();
8848        let endpoint = resolver.resolve_endpoint(&params);
8849        let error = endpoint
8850            .expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error]");
8851        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8852    }
8853}
8854
8855/// Endpoint resolver trait specific to Amazon Simple Storage Service
8856pub trait ResolveEndpoint: ::std::marker::Send + ::std::marker::Sync + ::std::fmt::Debug {
8857    /// Resolve an endpoint with the given parameters
8858    fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a>;
8859
8860    /// Convert this service-specific resolver into a `SharedEndpointResolver`
8861    ///
8862    /// The resulting resolver will downcast `EndpointResolverParams` into `crate::config::endpoint::Params`.
8863    fn into_shared_resolver(self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver
8864    where
8865        Self: Sized + 'static,
8866    {
8867        ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
8868    }
8869}
8870
8871#[derive(Debug)]
8872struct DowncastParams<T>(T);
8873impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
8874where
8875    T: ResolveEndpoint,
8876{
8877    fn resolve_endpoint<'a>(
8878        &'a self,
8879        params: &'a ::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams,
8880    ) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
8881        let ep = match params.get::<crate::config::endpoint::Params>() {
8882            Some(params) => self.0.resolve_endpoint(params),
8883            None => ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(Err("params of expected type was not present".into())),
8884        };
8885        ep
8886    }
8887}
8888
8889/// The default endpoint resolver
8890#[derive(Debug, Default)]
8891pub struct DefaultResolver {
8892    partition_resolver: crate::endpoint_lib::partition::PartitionResolver,
8893}
8894
8895impl DefaultResolver {
8896    /// Create a new endpoint resolver with default settings
8897    pub fn new() -> Self {
8898        Self {
8899            partition_resolver: crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER.clone(),
8900        }
8901    }
8902
8903    fn resolve_endpoint(
8904        &self,
8905        params: &crate::config::endpoint::Params,
8906    ) -> Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_runtime_api::box_error::BoxError> {
8907        let mut diagnostic_collector = crate::endpoint_lib::diagnostic::DiagnosticCollector::new();
8908        Ok(
8909            crate::config::endpoint::internals::resolve_endpoint(params, &mut diagnostic_collector, &self.partition_resolver)
8910                .map_err(|err| err.with_source(diagnostic_collector.take_last_error()))?,
8911        )
8912    }
8913}
8914
8915impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
8916    fn resolve_endpoint(&self, params: &crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture {
8917        ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(self.resolve_endpoint(params))
8918    }
8919}
8920
8921#[non_exhaustive]
8922#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
8923/// Configuration parameters for resolving the correct endpoint
8924pub struct Params {
8925    /// 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.
8926    pub(crate) bucket: ::std::option::Option<::std::string::String>,
8927    /// The AWS region used to dispatch the request.
8928    pub(crate) region: ::std::option::Option<::std::string::String>,
8929    /// 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.
8930    pub(crate) use_fips: bool,
8931    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
8932    pub(crate) use_dual_stack: bool,
8933    /// Override the endpoint used to send this request
8934    pub(crate) endpoint: ::std::option::Option<::std::string::String>,
8935    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
8936    pub(crate) force_path_style: bool,
8937    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
8938    pub(crate) accelerate: bool,
8939    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
8940    pub(crate) use_global_endpoint: bool,
8941    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
8942    pub(crate) use_object_lambda_endpoint: ::std::option::Option<bool>,
8943    /// 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.
8944    pub(crate) key: ::std::option::Option<::std::string::String>,
8945    /// 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.
8946    pub(crate) prefix: ::std::option::Option<::std::string::String>,
8947    /// 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.
8948    pub(crate) copy_source: ::std::option::Option<::std::string::String>,
8949    /// Internal parameter to disable Access Point Buckets
8950    pub(crate) disable_access_points: ::std::option::Option<bool>,
8951    /// Whether multi-region access points (MRAP) should be disabled.
8952    pub(crate) disable_multi_region_access_points: bool,
8953    /// 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.
8954    pub(crate) use_arn_region: ::std::option::Option<bool>,
8955    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
8956    pub(crate) use_s3_express_control_endpoint: ::std::option::Option<bool>,
8957    /// Parameter to indicate whether S3Express session auth should be disabled
8958    pub(crate) disable_s3_express_session_auth: ::std::option::Option<bool>,
8959}
8960impl Params {
8961    /// Create a builder for [`Params`]
8962    pub fn builder() -> crate::config::endpoint::ParamsBuilder {
8963        crate::config::endpoint::ParamsBuilder::default()
8964    }
8965    /// 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.
8966    pub fn bucket(&self) -> ::std::option::Option<&str> {
8967        self.bucket.as_deref()
8968    }
8969    /// The AWS region used to dispatch the request.
8970    pub fn region(&self) -> ::std::option::Option<&str> {
8971        self.region.as_deref()
8972    }
8973    /// 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.
8974    pub fn use_fips(&self) -> ::std::option::Option<bool> {
8975        Some(self.use_fips)
8976    }
8977    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
8978    pub fn use_dual_stack(&self) -> ::std::option::Option<bool> {
8979        Some(self.use_dual_stack)
8980    }
8981    /// Override the endpoint used to send this request
8982    pub fn endpoint(&self) -> ::std::option::Option<&str> {
8983        self.endpoint.as_deref()
8984    }
8985    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
8986    pub fn force_path_style(&self) -> ::std::option::Option<bool> {
8987        Some(self.force_path_style)
8988    }
8989    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
8990    pub fn accelerate(&self) -> ::std::option::Option<bool> {
8991        Some(self.accelerate)
8992    }
8993    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
8994    pub fn use_global_endpoint(&self) -> ::std::option::Option<bool> {
8995        Some(self.use_global_endpoint)
8996    }
8997    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
8998    pub fn use_object_lambda_endpoint(&self) -> ::std::option::Option<bool> {
8999        self.use_object_lambda_endpoint
9000    }
9001    /// 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.
9002    pub fn key(&self) -> ::std::option::Option<&str> {
9003        self.key.as_deref()
9004    }
9005    /// 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.
9006    pub fn prefix(&self) -> ::std::option::Option<&str> {
9007        self.prefix.as_deref()
9008    }
9009    /// 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.
9010    pub fn copy_source(&self) -> ::std::option::Option<&str> {
9011        self.copy_source.as_deref()
9012    }
9013    /// Internal parameter to disable Access Point Buckets
9014    pub fn disable_access_points(&self) -> ::std::option::Option<bool> {
9015        self.disable_access_points
9016    }
9017    /// Whether multi-region access points (MRAP) should be disabled.
9018    pub fn disable_multi_region_access_points(&self) -> ::std::option::Option<bool> {
9019        Some(self.disable_multi_region_access_points)
9020    }
9021    /// 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.
9022    pub fn use_arn_region(&self) -> ::std::option::Option<bool> {
9023        self.use_arn_region
9024    }
9025    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
9026    pub fn use_s3_express_control_endpoint(&self) -> ::std::option::Option<bool> {
9027        self.use_s3_express_control_endpoint
9028    }
9029    /// Parameter to indicate whether S3Express session auth should be disabled
9030    pub fn disable_s3_express_session_auth(&self) -> ::std::option::Option<bool> {
9031        self.disable_s3_express_session_auth
9032    }
9033}
9034
9035/// Builder for [`Params`]
9036#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
9037pub struct ParamsBuilder {
9038    bucket: ::std::option::Option<::std::string::String>,
9039    region: ::std::option::Option<::std::string::String>,
9040    use_fips: ::std::option::Option<bool>,
9041    use_dual_stack: ::std::option::Option<bool>,
9042    endpoint: ::std::option::Option<::std::string::String>,
9043    force_path_style: ::std::option::Option<bool>,
9044    accelerate: ::std::option::Option<bool>,
9045    use_global_endpoint: ::std::option::Option<bool>,
9046    use_object_lambda_endpoint: ::std::option::Option<bool>,
9047    key: ::std::option::Option<::std::string::String>,
9048    prefix: ::std::option::Option<::std::string::String>,
9049    copy_source: ::std::option::Option<::std::string::String>,
9050    disable_access_points: ::std::option::Option<bool>,
9051    disable_multi_region_access_points: ::std::option::Option<bool>,
9052    use_arn_region: ::std::option::Option<bool>,
9053    use_s3_express_control_endpoint: ::std::option::Option<bool>,
9054    disable_s3_express_session_auth: ::std::option::Option<bool>,
9055}
9056impl ParamsBuilder {
9057    /// Consume this builder, creating [`Params`].
9058    pub fn build(self) -> ::std::result::Result<crate::config::endpoint::Params, crate::config::endpoint::InvalidParams> {
9059        Ok(
9060            #[allow(clippy::unnecessary_lazy_evaluations)]
9061            crate::config::endpoint::Params {
9062                bucket: self.bucket,
9063                region: self.region,
9064                use_fips: self
9065                    .use_fips
9066                    .or_else(|| Some(false))
9067                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_fips"))?,
9068                use_dual_stack: self
9069                    .use_dual_stack
9070                    .or_else(|| Some(false))
9071                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_dual_stack"))?,
9072                endpoint: self.endpoint,
9073                force_path_style: self
9074                    .force_path_style
9075                    .or_else(|| Some(false))
9076                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("force_path_style"))?,
9077                accelerate: self
9078                    .accelerate
9079                    .or_else(|| Some(false))
9080                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("accelerate"))?,
9081                use_global_endpoint: self
9082                    .use_global_endpoint
9083                    .or_else(|| Some(false))
9084                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_global_endpoint"))?,
9085                use_object_lambda_endpoint: self.use_object_lambda_endpoint,
9086                key: self.key,
9087                prefix: self.prefix,
9088                copy_source: self.copy_source,
9089                disable_access_points: self.disable_access_points,
9090                disable_multi_region_access_points: self
9091                    .disable_multi_region_access_points
9092                    .or_else(|| Some(false))
9093                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("disable_multi_region_access_points"))?,
9094                use_arn_region: self.use_arn_region,
9095                use_s3_express_control_endpoint: self.use_s3_express_control_endpoint,
9096                disable_s3_express_session_auth: self.disable_s3_express_session_auth,
9097            },
9098        )
9099    }
9100    /// Sets the value for bucket
9101    ///
9102    /// 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.
9103    pub fn bucket(mut self, value: impl Into<::std::string::String>) -> Self {
9104        self.bucket = Some(value.into());
9105        self
9106    }
9107
9108    /// Sets the value for bucket
9109    ///
9110    /// 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.
9111    pub fn set_bucket(mut self, param: Option<::std::string::String>) -> Self {
9112        self.bucket = param;
9113        self
9114    }
9115    /// Sets the value for region
9116    ///
9117    /// The AWS region used to dispatch the request.
9118    pub fn region(mut self, value: impl Into<::std::string::String>) -> Self {
9119        self.region = Some(value.into());
9120        self
9121    }
9122
9123    /// Sets the value for region
9124    ///
9125    /// The AWS region used to dispatch the request.
9126    pub fn set_region(mut self, param: Option<::std::string::String>) -> Self {
9127        self.region = param;
9128        self
9129    }
9130    /// Sets the value for use_fips
9131    ///
9132    /// When unset, this parameter has a default value of `false`.
9133    /// 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.
9134    pub fn use_fips(mut self, value: impl Into<bool>) -> Self {
9135        self.use_fips = Some(value.into());
9136        self
9137    }
9138
9139    /// Sets the value for use_fips
9140    ///
9141    /// When unset, this parameter has a default value of `false`.
9142    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
9143    pub fn set_use_fips(mut self, param: Option<bool>) -> Self {
9144        self.use_fips = param;
9145        self
9146    }
9147    /// Sets the value for use_dual_stack
9148    ///
9149    /// When unset, this parameter has a default value of `false`.
9150    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
9151    pub fn use_dual_stack(mut self, value: impl Into<bool>) -> Self {
9152        self.use_dual_stack = Some(value.into());
9153        self
9154    }
9155
9156    /// Sets the value for use_dual_stack
9157    ///
9158    /// When unset, this parameter has a default value of `false`.
9159    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
9160    pub fn set_use_dual_stack(mut self, param: Option<bool>) -> Self {
9161        self.use_dual_stack = param;
9162        self
9163    }
9164    /// Sets the value for endpoint
9165    ///
9166    /// Override the endpoint used to send this request
9167    pub fn endpoint(mut self, value: impl Into<::std::string::String>) -> Self {
9168        self.endpoint = Some(value.into());
9169        self
9170    }
9171
9172    /// Sets the value for endpoint
9173    ///
9174    /// Override the endpoint used to send this request
9175    pub fn set_endpoint(mut self, param: Option<::std::string::String>) -> Self {
9176        self.endpoint = param;
9177        self
9178    }
9179    /// Sets the value for force_path_style
9180    ///
9181    /// When unset, this parameter has a default value of `false`.
9182    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
9183    pub fn force_path_style(mut self, value: impl Into<bool>) -> Self {
9184        self.force_path_style = Some(value.into());
9185        self
9186    }
9187
9188    /// Sets the value for force_path_style
9189    ///
9190    /// When unset, this parameter has a default value of `false`.
9191    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
9192    pub fn set_force_path_style(mut self, param: Option<bool>) -> Self {
9193        self.force_path_style = param;
9194        self
9195    }
9196    /// Sets the value for accelerate
9197    ///
9198    /// When unset, this parameter has a default value of `false`.
9199    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
9200    pub fn accelerate(mut self, value: impl Into<bool>) -> Self {
9201        self.accelerate = Some(value.into());
9202        self
9203    }
9204
9205    /// Sets the value for accelerate
9206    ///
9207    /// When unset, this parameter has a default value of `false`.
9208    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
9209    pub fn set_accelerate(mut self, param: Option<bool>) -> Self {
9210        self.accelerate = param;
9211        self
9212    }
9213    /// Sets the value for use_global_endpoint
9214    ///
9215    /// When unset, this parameter has a default value of `false`.
9216    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
9217    pub fn use_global_endpoint(mut self, value: impl Into<bool>) -> Self {
9218        self.use_global_endpoint = Some(value.into());
9219        self
9220    }
9221
9222    /// Sets the value for use_global_endpoint
9223    ///
9224    /// When unset, this parameter has a default value of `false`.
9225    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
9226    pub fn set_use_global_endpoint(mut self, param: Option<bool>) -> Self {
9227        self.use_global_endpoint = param;
9228        self
9229    }
9230    /// Sets the value for use_object_lambda_endpoint
9231    ///
9232    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
9233    pub fn use_object_lambda_endpoint(mut self, value: impl Into<bool>) -> Self {
9234        self.use_object_lambda_endpoint = Some(value.into());
9235        self
9236    }
9237
9238    /// Sets the value for use_object_lambda_endpoint
9239    ///
9240    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
9241    pub fn set_use_object_lambda_endpoint(mut self, param: Option<bool>) -> Self {
9242        self.use_object_lambda_endpoint = param;
9243        self
9244    }
9245    /// Sets the value for key
9246    ///
9247    /// 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.
9248    pub fn key(mut self, value: impl Into<::std::string::String>) -> Self {
9249        self.key = Some(value.into());
9250        self
9251    }
9252
9253    /// Sets the value for key
9254    ///
9255    /// 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.
9256    pub fn set_key(mut self, param: Option<::std::string::String>) -> Self {
9257        self.key = param;
9258        self
9259    }
9260    /// Sets the value for prefix
9261    ///
9262    /// 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.
9263    pub fn prefix(mut self, value: impl Into<::std::string::String>) -> Self {
9264        self.prefix = Some(value.into());
9265        self
9266    }
9267
9268    /// Sets the value for prefix
9269    ///
9270    /// 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.
9271    pub fn set_prefix(mut self, param: Option<::std::string::String>) -> Self {
9272        self.prefix = param;
9273        self
9274    }
9275    /// Sets the value for copy_source
9276    ///
9277    /// 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.
9278    pub fn copy_source(mut self, value: impl Into<::std::string::String>) -> Self {
9279        self.copy_source = Some(value.into());
9280        self
9281    }
9282
9283    /// Sets the value for copy_source
9284    ///
9285    /// 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.
9286    pub fn set_copy_source(mut self, param: Option<::std::string::String>) -> Self {
9287        self.copy_source = param;
9288        self
9289    }
9290    /// Sets the value for disable_access_points
9291    ///
9292    /// Internal parameter to disable Access Point Buckets
9293    pub fn disable_access_points(mut self, value: impl Into<bool>) -> Self {
9294        self.disable_access_points = Some(value.into());
9295        self
9296    }
9297
9298    /// Sets the value for disable_access_points
9299    ///
9300    /// Internal parameter to disable Access Point Buckets
9301    pub fn set_disable_access_points(mut self, param: Option<bool>) -> Self {
9302        self.disable_access_points = param;
9303        self
9304    }
9305    /// Sets the value for disable_multi_region_access_points
9306    ///
9307    /// When unset, this parameter has a default value of `false`.
9308    /// Whether multi-region access points (MRAP) should be disabled.
9309    pub fn disable_multi_region_access_points(mut self, value: impl Into<bool>) -> Self {
9310        self.disable_multi_region_access_points = Some(value.into());
9311        self
9312    }
9313
9314    /// Sets the value for disable_multi_region_access_points
9315    ///
9316    /// When unset, this parameter has a default value of `false`.
9317    /// Whether multi-region access points (MRAP) should be disabled.
9318    pub fn set_disable_multi_region_access_points(mut self, param: Option<bool>) -> Self {
9319        self.disable_multi_region_access_points = param;
9320        self
9321    }
9322    /// Sets the value for use_arn_region
9323    ///
9324    /// 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.
9325    pub fn use_arn_region(mut self, value: impl Into<bool>) -> Self {
9326        self.use_arn_region = Some(value.into());
9327        self
9328    }
9329
9330    /// Sets the value for use_arn_region
9331    ///
9332    /// 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.
9333    pub fn set_use_arn_region(mut self, param: Option<bool>) -> Self {
9334        self.use_arn_region = param;
9335        self
9336    }
9337    /// Sets the value for use_s3_express_control_endpoint
9338    ///
9339    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
9340    pub fn use_s3_express_control_endpoint(mut self, value: impl Into<bool>) -> Self {
9341        self.use_s3_express_control_endpoint = Some(value.into());
9342        self
9343    }
9344
9345    /// Sets the value for use_s3_express_control_endpoint
9346    ///
9347    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
9348    pub fn set_use_s3_express_control_endpoint(mut self, param: Option<bool>) -> Self {
9349        self.use_s3_express_control_endpoint = param;
9350        self
9351    }
9352    /// Sets the value for disable_s3_express_session_auth
9353    ///
9354    /// Parameter to indicate whether S3Express session auth should be disabled
9355    pub fn disable_s3_express_session_auth(mut self, value: impl Into<bool>) -> Self {
9356        self.disable_s3_express_session_auth = Some(value.into());
9357        self
9358    }
9359
9360    /// Sets the value for disable_s3_express_session_auth
9361    ///
9362    /// Parameter to indicate whether S3Express session auth should be disabled
9363    pub fn set_disable_s3_express_session_auth(mut self, param: Option<bool>) -> Self {
9364        self.disable_s3_express_session_auth = param;
9365        self
9366    }
9367}
9368
9369/// An error that occurred during endpoint resolution
9370#[derive(Debug)]
9371pub struct InvalidParams {
9372    field: std::borrow::Cow<'static, str>,
9373}
9374
9375impl InvalidParams {
9376    #[allow(dead_code)]
9377    fn missing(field: &'static str) -> Self {
9378        Self { field: field.into() }
9379    }
9380}
9381
9382impl std::fmt::Display for InvalidParams {
9383    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9384        write!(f, "a required field was missing: `{}`", self.field)
9385    }
9386}
9387
9388impl std::error::Error for InvalidParams {}
9389
9390mod internals;
aws_sdk_s3/config/endpoint.rs

aws_sdk_s3/config/
endpoint.rs
