aws_sdk_s3/config/
endpoint.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2pub use ::aws_smithy_runtime_api::client::endpoint::EndpointFuture;
3pub use ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver;
4pub use ::aws_smithy_types::endpoint::Endpoint;
5
6/// Interceptor that tracks endpoint override business metric.
7#[derive(Debug, Default)]
8pub(crate) struct EndpointOverrideFeatureTrackerInterceptor;
9
10#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
11impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EndpointOverrideFeatureTrackerInterceptor {
12    fn name(&self) -> &'static str {
13        "EndpointOverrideFeatureTrackerInterceptor"
14    }
15
16    fn read_before_execution(
17        &self,
18        _context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<'_>,
19        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
20    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
21        if cfg.load::<::aws_types::endpoint_config::EndpointUrl>().is_some() {
22            cfg.interceptor_state()
23                .store_append(::aws_runtime::sdk_feature::AwsSdkFeature::EndpointOverride);
24        }
25        ::std::result::Result::Ok(())
26    }
27}
28
29#[cfg(test)]
30mod test {
31
32    /// region is not a valid DNS-suffix
33    #[test]
34    fn test_1() {
35        let params = crate::config::endpoint::Params::builder()
36            .region("a b".to_string())
37            .use_fips(false)
38            .use_dual_stack(false)
39            .accelerate(false)
40            .build()
41            .expect("invalid params");
42        let resolver = crate::config::endpoint::DefaultResolver::new();
43        let endpoint = resolver.resolve_endpoint(&params);
44        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [region is not a valid DNS-suffix]");
45        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
46    }
47
48    /// Invalid access point ARN: Not S3
49    #[test]
50    fn test_2() {
51        let params = crate::config::endpoint::Params::builder()
52            .region("us-east-1".to_string())
53            .use_fips(false)
54            .use_dual_stack(false)
55            .accelerate(false)
56            .bucket("arn:aws:not-s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
57            .build()
58            .expect("invalid params");
59        let resolver = crate::config::endpoint::DefaultResolver::new();
60        let endpoint = resolver.resolve_endpoint(&params);
61        let error =
62            endpoint.expect_err("expected error: Invalid ARN: The ARN was not for the S3 service, found: not-s3 [Invalid access point ARN: Not S3]");
63        assert_eq!(format!("{}", error), "Invalid ARN: The ARN was not for the S3 service, found: not-s3")
64    }
65
66    /// Invalid access point ARN: invalid resource
67    #[test]
68    fn test_3() {
69        let params = crate::config::endpoint::Params::builder()
70            .region("us-east-1".to_string())
71            .use_fips(false)
72            .use_dual_stack(false)
73            .accelerate(false)
74            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint:more-data".to_string())
75            .build()
76            .expect("invalid params");
77        let resolver = crate::config::endpoint::DefaultResolver::new();
78        let endpoint = resolver.resolve_endpoint(&params);
79        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]");
80        assert_eq!(
81            format!("{}", error),
82            "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`."
83        )
84    }
85
86    /// Invalid access point ARN: invalid no ap name
87    #[test]
88    fn test_4() {
89        let params = crate::config::endpoint::Params::builder()
90            .region("us-east-1".to_string())
91            .use_fips(false)
92            .use_dual_stack(false)
93            .accelerate(false)
94            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:".to_string())
95            .build()
96            .expect("invalid params");
97        let resolver = crate::config::endpoint::DefaultResolver::new();
98        let endpoint = resolver.resolve_endpoint(&params);
99        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]");
100        assert_eq!(
101            format!("{}", error),
102            "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided"
103        )
104    }
105
106    /// Invalid access point ARN: AccountId is invalid
107    #[test]
108    fn test_5() {
109        let params = crate::config::endpoint::Params::builder()
110            .region("us-east-1".to_string())
111            .use_fips(false)
112            .use_dual_stack(false)
113            .accelerate(false)
114            .bucket("arn:aws:s3:us-west-2:123456_789012:accesspoint:apname".to_string())
115            .build()
116            .expect("invalid params");
117        let resolver = crate::config::endpoint::DefaultResolver::new();
118        let endpoint = resolver.resolve_endpoint(&params);
119        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]");
120        assert_eq!(
121            format!("{}", error),
122            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123456_789012`"
123        )
124    }
125
126    /// Invalid access point ARN: access point name is invalid
127    #[test]
128    fn test_6() {
129        let params = crate::config::endpoint::Params::builder()
130            .region("us-east-1".to_string())
131            .use_fips(false)
132            .use_dual_stack(false)
133            .accelerate(false)
134            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:ap_name".to_string())
135            .build()
136            .expect("invalid params");
137        let resolver = crate::config::endpoint::DefaultResolver::new();
138        let endpoint = resolver.resolve_endpoint(&params);
139        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]");
140        assert_eq!(
141            format!("{}", error),
142            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `ap_name`"
143        )
144    }
145
146    /// Access points (disable access points explicitly false)
147    #[test]
148    fn test_7() {
149        let params = crate::config::endpoint::Params::builder()
150            .region("us-east-1".to_string())
151            .use_fips(false)
152            .use_dual_stack(false)
153            .accelerate(false)
154            .disable_access_points(false)
155            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
156            .build()
157            .expect("invalid params");
158        let resolver = crate::config::endpoint::DefaultResolver::new();
159        let endpoint = resolver.resolve_endpoint(&params);
160        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
161        assert_eq!(
162            endpoint,
163            ::aws_smithy_types::endpoint::Endpoint::builder()
164                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
165                .auth_scheme(
166                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
167                        .put("disableDoubleEncoding", true)
168                        .put("signingName", "s3".to_string())
169                        .put("signingRegion", "us-west-2".to_string())
170                )
171                .build()
172        );
173    }
174
175    /// Access points: partition does not support FIPS
176    #[test]
177    fn test_8() {
178        let params = crate::config::endpoint::Params::builder()
179            .region("cn-north-1".to_string())
180            .use_fips(true)
181            .use_dual_stack(false)
182            .accelerate(false)
183            .bucket("arn:aws:s3:cn-north-1: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: Partition does not support FIPS [Access points: partition does not support FIPS]");
189        assert_eq!(format!("{}", error), "Partition does not support FIPS")
190    }
191
192    /// Bucket region is invalid
193    #[test]
194    fn test_9() {
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(false)
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: Invalid region in ARN: `us-west -2` (invalid DNS name) [Bucket region is invalid]");
207        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-west -2` (invalid DNS name)")
208    }
209
210    /// Access points when Access points explicitly disabled (used for CreateBucket)
211    #[test]
212    fn test_10() {
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:accesspoint:myendpoint".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: Access points are not supported for this operation [Access points when Access points explicitly disabled (used for CreateBucket)]");
225        assert_eq!(format!("{}", error), "Access points are not supported for this operation")
226    }
227
228    /// missing arn type
229    #[test]
230    fn test_11() {
231        let params = crate::config::endpoint::Params::builder()
232            .region("us-east-1".to_string())
233            .use_fips(false)
234            .use_dual_stack(false)
235            .accelerate(false)
236            .disable_access_points(true)
237            .bucket("arn:aws:s3:us-west-2:123456789012:".to_string())
238            .build()
239            .expect("invalid params");
240        let resolver = crate::config::endpoint::DefaultResolver::new();
241        let endpoint = resolver.resolve_endpoint(&params);
242        let error = endpoint.expect_err("expected error: Invalid ARN: `arn:aws:s3:us-west-2:123456789012:` was not a valid ARN [missing arn type]");
243        assert_eq!(
244            format!("{}", error),
245            "Invalid ARN: `arn:aws:s3:us-west-2:123456789012:` was not a valid ARN"
246        )
247    }
248
249    /// SDK::Host + access point + Dualstack is an error
250    #[test]
251    fn test_12() {
252        let params = crate::config::endpoint::Params::builder()
253            .accelerate(false)
254            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
255            .force_path_style(false)
256            .endpoint("https://beta.example.com".to_string())
257            .region("cn-north-1".to_string())
258            .use_dual_stack(true)
259            .use_fips(false)
260            .build()
261            .expect("invalid params");
262        let resolver = crate::config::endpoint::DefaultResolver::new();
263        let endpoint = resolver.resolve_endpoint(&params);
264        let error = endpoint.expect_err(
265            "expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + access point + Dualstack is an error]",
266        );
267        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
268    }
269
270    /// Access point ARN with FIPS & Dualstack
271    #[test]
272    fn test_13() {
273        let params = crate::config::endpoint::Params::builder()
274            .region("us-east-1".to_string())
275            .use_fips(true)
276            .use_dual_stack(true)
277            .accelerate(false)
278            .disable_access_points(false)
279            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
280            .build()
281            .expect("invalid params");
282        let resolver = crate::config::endpoint::DefaultResolver::new();
283        let endpoint = resolver.resolve_endpoint(&params);
284        let endpoint =
285            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com");
286        assert_eq!(
287            endpoint,
288            ::aws_smithy_types::endpoint::Endpoint::builder()
289                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com")
290                .auth_scheme(
291                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
292                        .put("disableDoubleEncoding", true)
293                        .put("signingName", "s3".to_string())
294                        .put("signingRegion", "us-west-2".to_string())
295                )
296                .build()
297        );
298    }
299
300    /// Access point ARN with Dualstack
301    #[test]
302    fn test_14() {
303        let params = crate::config::endpoint::Params::builder()
304            .region("us-east-1".to_string())
305            .use_fips(false)
306            .use_dual_stack(true)
307            .accelerate(false)
308            .disable_access_points(false)
309            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
310            .build()
311            .expect("invalid params");
312        let resolver = crate::config::endpoint::DefaultResolver::new();
313        let endpoint = resolver.resolve_endpoint(&params);
314        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.dualstack.us-west-2.amazonaws.com");
315        assert_eq!(
316            endpoint,
317            ::aws_smithy_types::endpoint::Endpoint::builder()
318                .url("https://myendpoint-123456789012.s3-accesspoint.dualstack.us-west-2.amazonaws.com")
319                .auth_scheme(
320                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
321                        .put("disableDoubleEncoding", true)
322                        .put("signingName", "s3".to_string())
323                        .put("signingRegion", "us-west-2".to_string())
324                )
325                .build()
326        );
327    }
328
329    /// vanilla MRAP
330    #[test]
331    fn test_15() {
332        let params = crate::config::endpoint::Params::builder()
333            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
334            .region("us-east-1".to_string())
335            .disable_multi_region_access_points(false)
336            .use_fips(false)
337            .use_dual_stack(false)
338            .accelerate(false)
339            .build()
340            .expect("invalid params");
341        let resolver = crate::config::endpoint::DefaultResolver::new();
342        let endpoint = resolver.resolve_endpoint(&params);
343        let endpoint = endpoint.expect("Expected valid endpoint: https://mfzwi23gnjvgw.mrap.accesspoint.s3-global.amazonaws.com");
344        assert_eq!(
345            endpoint,
346            ::aws_smithy_types::endpoint::Endpoint::builder()
347                .url("https://mfzwi23gnjvgw.mrap.accesspoint.s3-global.amazonaws.com")
348                .auth_scheme(
349                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
350                        .put("disableDoubleEncoding", true)
351                        .put("signingName", "s3".to_string())
352                        .put("signingRegionSet", vec!["*".to_string().into()])
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                .auth_scheme(
454                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
455                        .put("disableDoubleEncoding", true)
456                        .put("signingName", "s3".to_string())
457                        .put("signingRegion", "us-west-2".to_string())
458                )
459                .build()
460        );
461    }
462
463    /// Dual-stack endpoint + SDK::Host is error
464    #[test]
465    fn test_21() {
466        let params = crate::config::endpoint::Params::builder()
467            .bucket("bucketname".to_string())
468            .region("us-west-2".to_string())
469            .force_path_style(true)
470            .use_fips(false)
471            .accelerate(false)
472            .use_dual_stack(true)
473            .endpoint("https://abc.com".to_string())
474            .build()
475            .expect("invalid params");
476        let resolver = crate::config::endpoint::DefaultResolver::new();
477        let endpoint = resolver.resolve_endpoint(&params);
478        let error = endpoint
479            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [Dual-stack endpoint + SDK::Host is error]");
480        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
481    }
482
483    /// path style + ARN bucket
484    #[test]
485    fn test_22() {
486        let params = crate::config::endpoint::Params::builder()
487            .accelerate(false)
488            .bucket("arn:aws:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
489            .force_path_style(true)
490            .region("us-west-2".to_string())
491            .use_dual_stack(false)
492            .use_fips(false)
493            .build()
494            .expect("invalid params");
495        let resolver = crate::config::endpoint::DefaultResolver::new();
496        let endpoint = resolver.resolve_endpoint(&params);
497        let error = endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + ARN bucket]");
498        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
499    }
500
501    /// implicit path style bucket + dualstack
502    #[test]
503    fn test_23() {
504        let params = crate::config::endpoint::Params::builder()
505            .accelerate(false)
506            .bucket("99_ab".to_string())
507            .region("us-west-2".to_string())
508            .use_dual_stack(true)
509            .use_fips(false)
510            .build()
511            .expect("invalid params");
512        let resolver = crate::config::endpoint::DefaultResolver::new();
513        let endpoint = resolver.resolve_endpoint(&params);
514        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/99_ab");
515        assert_eq!(
516            endpoint,
517            ::aws_smithy_types::endpoint::Endpoint::builder()
518                .url("https://s3.dualstack.us-west-2.amazonaws.com/99_ab")
519                .auth_scheme(
520                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
521                        .put("disableDoubleEncoding", true)
522                        .put("signingName", "s3".to_string())
523                        .put("signingRegion", "us-west-2".to_string())
524                )
525                .build()
526        );
527    }
528
529    /// implicit path style bucket + dualstack
530    #[test]
531    fn test_24() {
532        let params = crate::config::endpoint::Params::builder()
533            .accelerate(false)
534            .bucket("99_ab".to_string())
535            .region("us-west-2".to_string())
536            .use_dual_stack(true)
537            .use_fips(false)
538            .endpoint("http://abc.com".to_string())
539            .build()
540            .expect("invalid params");
541        let resolver = crate::config::endpoint::DefaultResolver::new();
542        let endpoint = resolver.resolve_endpoint(&params);
543        let error = endpoint
544            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [implicit path style bucket + dualstack]");
545        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
546    }
547
548    /// don't allow URL injections in the bucket
549    #[test]
550    fn test_25() {
551        let params = crate::config::endpoint::Params::builder()
552            .bucket("example.com#".to_string())
553            .region("us-west-2".to_string())
554            .use_dual_stack(false)
555            .use_fips(false)
556            .accelerate(false)
557            .build()
558            .expect("invalid params");
559        let resolver = crate::config::endpoint::DefaultResolver::new();
560        let endpoint = resolver.resolve_endpoint(&params);
561        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/example.com%23");
562        assert_eq!(
563            endpoint,
564            ::aws_smithy_types::endpoint::Endpoint::builder()
565                .url("https://s3.us-west-2.amazonaws.com/example.com%23")
566                .auth_scheme(
567                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
568                        .put("disableDoubleEncoding", true)
569                        .put("signingName", "s3".to_string())
570                        .put("signingRegion", "us-west-2".to_string())
571                )
572                .build()
573        );
574    }
575
576    /// URI encode bucket names in the path
577    #[test]
578    fn test_26() {
579        let params = crate::config::endpoint::Params::builder()
580            .bucket("bucket name".to_string())
581            .region("us-west-2".to_string())
582            .use_dual_stack(false)
583            .use_fips(false)
584            .accelerate(false)
585            .build()
586            .expect("invalid params");
587        let resolver = crate::config::endpoint::DefaultResolver::new();
588        let endpoint = resolver.resolve_endpoint(&params);
589        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket%20name");
590        assert_eq!(
591            endpoint,
592            ::aws_smithy_types::endpoint::Endpoint::builder()
593                .url("https://s3.us-west-2.amazonaws.com/bucket%20name")
594                .auth_scheme(
595                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
596                        .put("disableDoubleEncoding", true)
597                        .put("signingName", "s3".to_string())
598                        .put("signingRegion", "us-west-2".to_string())
599                )
600                .build()
601        );
602    }
603
604    /// scheme is respected
605    #[test]
606    fn test_27() {
607        let params = crate::config::endpoint::Params::builder()
608            .accelerate(false)
609            .bucket("99_ab".to_string())
610            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
611            .region("af-south-1".to_string())
612            .use_dual_stack(false)
613            .use_fips(false)
614            .build()
615            .expect("invalid params");
616        let resolver = crate::config::endpoint::DefaultResolver::new();
617        let endpoint = resolver.resolve_endpoint(&params);
618        let endpoint = endpoint.expect("Expected valid endpoint: http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab");
619        assert_eq!(
620            endpoint,
621            ::aws_smithy_types::endpoint::Endpoint::builder()
622                .url("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab")
623                .auth_scheme(
624                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
625                        .put("disableDoubleEncoding", true)
626                        .put("signingName", "s3".to_string())
627                        .put("signingRegion", "af-south-1".to_string())
628                )
629                .build()
630        );
631    }
632
633    /// scheme is respected (virtual addressing)
634    #[test]
635    fn test_28() {
636        let params = crate::config::endpoint::Params::builder()
637            .accelerate(false)
638            .bucket("bucketname".to_string())
639            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo".to_string())
640            .region("af-south-1".to_string())
641            .use_dual_stack(false)
642            .use_fips(false)
643            .build()
644            .expect("invalid params");
645        let resolver = crate::config::endpoint::DefaultResolver::new();
646        let endpoint = resolver.resolve_endpoint(&params);
647        let endpoint = endpoint.expect("Expected valid endpoint: http://bucketname.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo");
648        assert_eq!(
649            endpoint,
650            ::aws_smithy_types::endpoint::Endpoint::builder()
651                .url("http://bucketname.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/foo")
652                .auth_scheme(
653                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
654                        .put("disableDoubleEncoding", true)
655                        .put("signingName", "s3".to_string())
656                        .put("signingRegion", "af-south-1".to_string())
657                )
658                .build()
659        );
660    }
661
662    /// path style + implicit private link
663    #[test]
664    fn test_29() {
665        let params = crate::config::endpoint::Params::builder()
666            .accelerate(false)
667            .bucket("99_ab".to_string())
668            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
669            .region("af-south-1".to_string())
670            .use_dual_stack(false)
671            .use_fips(false)
672            .build()
673            .expect("invalid params");
674        let resolver = crate::config::endpoint::DefaultResolver::new();
675        let endpoint = resolver.resolve_endpoint(&params);
676        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab");
677        assert_eq!(
678            endpoint,
679            ::aws_smithy_types::endpoint::Endpoint::builder()
680                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/99_ab")
681                .auth_scheme(
682                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
683                        .put("disableDoubleEncoding", true)
684                        .put("signingName", "s3".to_string())
685                        .put("signingRegion", "af-south-1".to_string())
686                )
687                .build()
688        );
689    }
690
691    /// invalid Endpoint override
692    #[test]
693    fn test_30() {
694        let params = crate::config::endpoint::Params::builder()
695            .accelerate(false)
696            .bucket("bucketname".to_string())
697            .endpoint("abcde://nota#url".to_string())
698            .region("af-south-1".to_string())
699            .use_dual_stack(false)
700            .use_fips(false)
701            .build()
702            .expect("invalid params");
703        let resolver = crate::config::endpoint::DefaultResolver::new();
704        let endpoint = resolver.resolve_endpoint(&params);
705        let error = endpoint.expect_err("expected error: Custom endpoint `abcde://nota#url` was not a valid URI [invalid Endpoint override]");
706        assert_eq!(format!("{}", error), "Custom endpoint `abcde://nota#url` was not a valid URI")
707    }
708
709    /// using an IPv4 address forces path style
710    #[test]
711    fn test_31() {
712        let params = crate::config::endpoint::Params::builder()
713            .accelerate(false)
714            .bucket("bucketname".to_string())
715            .endpoint("https://123.123.0.1".to_string())
716            .region("af-south-1".to_string())
717            .use_dual_stack(false)
718            .use_fips(false)
719            .build()
720            .expect("invalid params");
721        let resolver = crate::config::endpoint::DefaultResolver::new();
722        let endpoint = resolver.resolve_endpoint(&params);
723        let endpoint = endpoint.expect("Expected valid endpoint: https://123.123.0.1/bucketname");
724        assert_eq!(
725            endpoint,
726            ::aws_smithy_types::endpoint::Endpoint::builder()
727                .url("https://123.123.0.1/bucketname")
728                .auth_scheme(
729                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
730                        .put("disableDoubleEncoding", true)
731                        .put("signingName", "s3".to_string())
732                        .put("signingRegion", "af-south-1".to_string())
733                )
734                .build()
735        );
736    }
737
738    /// vanilla access point arn with region mismatch and UseArnRegion=false
739    #[test]
740    fn test_32() {
741        let params = crate::config::endpoint::Params::builder()
742            .accelerate(false)
743            .bucket("arn:aws:s3:us-east-1:123456789012:accesspoint:myendpoint".to_string())
744            .force_path_style(false)
745            .use_arn_region(false)
746            .region("us-west-2".to_string())
747            .use_dual_stack(false)
748            .use_fips(false)
749            .build()
750            .expect("invalid params");
751        let resolver = crate::config::endpoint::DefaultResolver::new();
752        let endpoint = resolver.resolve_endpoint(&params);
753        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]");
754        assert_eq!(
755            format!("{}", error),
756            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
757        )
758    }
759
760    /// vanilla access point arn with region mismatch and UseArnRegion unset
761    #[test]
762    fn test_33() {
763        let params = crate::config::endpoint::Params::builder()
764            .accelerate(false)
765            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
766            .force_path_style(false)
767            .region("us-east-1".to_string())
768            .use_dual_stack(false)
769            .use_fips(false)
770            .build()
771            .expect("invalid params");
772        let resolver = crate::config::endpoint::DefaultResolver::new();
773        let endpoint = resolver.resolve_endpoint(&params);
774        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
775        assert_eq!(
776            endpoint,
777            ::aws_smithy_types::endpoint::Endpoint::builder()
778                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
779                .auth_scheme(
780                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
781                        .put("disableDoubleEncoding", true)
782                        .put("signingName", "s3".to_string())
783                        .put("signingRegion", "us-west-2".to_string())
784                )
785                .build()
786        );
787    }
788
789    /// vanilla access point arn with region mismatch and UseArnRegion=true
790    #[test]
791    fn test_34() {
792        let params = crate::config::endpoint::Params::builder()
793            .accelerate(false)
794            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
795            .force_path_style(false)
796            .use_arn_region(true)
797            .region("us-east-1".to_string())
798            .use_dual_stack(false)
799            .use_fips(false)
800            .build()
801            .expect("invalid params");
802        let resolver = crate::config::endpoint::DefaultResolver::new();
803        let endpoint = resolver.resolve_endpoint(&params);
804        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
805        assert_eq!(
806            endpoint,
807            ::aws_smithy_types::endpoint::Endpoint::builder()
808                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
809                .auth_scheme(
810                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
811                        .put("disableDoubleEncoding", true)
812                        .put("signingName", "s3".to_string())
813                        .put("signingRegion", "us-west-2".to_string())
814                )
815                .build()
816        );
817    }
818
819    /// subdomains are not allowed in virtual buckets
820    #[test]
821    fn test_35() {
822        let params = crate::config::endpoint::Params::builder()
823            .bucket("bucket.name".to_string())
824            .region("us-east-1".to_string())
825            .build()
826            .expect("invalid params");
827        let resolver = crate::config::endpoint::DefaultResolver::new();
828        let endpoint = resolver.resolve_endpoint(&params);
829        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/bucket.name");
830        assert_eq!(
831            endpoint,
832            ::aws_smithy_types::endpoint::Endpoint::builder()
833                .url("https://s3.us-east-1.amazonaws.com/bucket.name")
834                .auth_scheme(
835                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
836                        .put("disableDoubleEncoding", true)
837                        .put("signingName", "s3".to_string())
838                        .put("signingRegion", "us-east-1".to_string())
839                )
840                .build()
841        );
842    }
843
844    /// bucket names with 3 characters are allowed in virtual buckets
845    #[test]
846    fn test_36() {
847        let params = crate::config::endpoint::Params::builder()
848            .bucket("aaa".to_string())
849            .region("us-east-1".to_string())
850            .build()
851            .expect("invalid params");
852        let resolver = crate::config::endpoint::DefaultResolver::new();
853        let endpoint = resolver.resolve_endpoint(&params);
854        let endpoint = endpoint.expect("Expected valid endpoint: https://aaa.s3.us-east-1.amazonaws.com");
855        assert_eq!(
856            endpoint,
857            ::aws_smithy_types::endpoint::Endpoint::builder()
858                .url("https://aaa.s3.us-east-1.amazonaws.com")
859                .auth_scheme(
860                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
861                        .put("disableDoubleEncoding", true)
862                        .put("signingName", "s3".to_string())
863                        .put("signingRegion", "us-east-1".to_string())
864                )
865                .build()
866        );
867    }
868
869    /// bucket names with fewer than 3 characters are not allowed in virtual host
870    #[test]
871    fn test_37() {
872        let params = crate::config::endpoint::Params::builder()
873            .bucket("aa".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/aa");
880        assert_eq!(
881            endpoint,
882            ::aws_smithy_types::endpoint::Endpoint::builder()
883                .url("https://s3.us-east-1.amazonaws.com/aa")
884                .auth_scheme(
885                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
886                        .put("disableDoubleEncoding", true)
887                        .put("signingName", "s3".to_string())
888                        .put("signingRegion", "us-east-1".to_string())
889                )
890                .build()
891        );
892    }
893
894    /// bucket names with uppercase characters are not allowed in virtual host
895    #[test]
896    fn test_38() {
897        let params = crate::config::endpoint::Params::builder()
898            .bucket("BucketName".to_string())
899            .region("us-east-1".to_string())
900            .build()
901            .expect("invalid params");
902        let resolver = crate::config::endpoint::DefaultResolver::new();
903        let endpoint = resolver.resolve_endpoint(&params);
904        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-1.amazonaws.com/BucketName");
905        assert_eq!(
906            endpoint,
907            ::aws_smithy_types::endpoint::Endpoint::builder()
908                .url("https://s3.us-east-1.amazonaws.com/BucketName")
909                .auth_scheme(
910                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
911                        .put("disableDoubleEncoding", true)
912                        .put("signingName", "s3".to_string())
913                        .put("signingRegion", "us-east-1".to_string())
914                )
915                .build()
916        );
917    }
918
919    /// subdomains are allowed in virtual buckets on http endpoints
920    #[test]
921    fn test_39() {
922        let params = crate::config::endpoint::Params::builder()
923            .bucket("bucket.name".to_string())
924            .region("us-east-1".to_string())
925            .endpoint("http://example.com".to_string())
926            .build()
927            .expect("invalid params");
928        let resolver = crate::config::endpoint::DefaultResolver::new();
929        let endpoint = resolver.resolve_endpoint(&params);
930        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket.name.example.com");
931        assert_eq!(
932            endpoint,
933            ::aws_smithy_types::endpoint::Endpoint::builder()
934                .url("http://bucket.name.example.com")
935                .auth_scheme(
936                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
937                        .put("disableDoubleEncoding", true)
938                        .put("signingName", "s3".to_string())
939                        .put("signingRegion", "us-east-1".to_string())
940                )
941                .build()
942        );
943    }
944
945    /// no region set
946    #[test]
947    fn test_40() {
948        let params = crate::config::endpoint::Params::builder()
949            .bucket("bucket-name".to_string())
950            .build()
951            .expect("invalid params");
952        let resolver = crate::config::endpoint::DefaultResolver::new();
953        let endpoint = resolver.resolve_endpoint(&params);
954        let error = endpoint.expect_err("expected error: A region must be set when sending requests to S3. [no region set]");
955        assert_eq!(format!("{}", error), "A region must be set when sending requests to S3.")
956    }
957
958    /// UseGlobalEndpoints=true, region=us-east-1 uses the global endpoint
959    #[test]
960    fn test_41() {
961        let params = crate::config::endpoint::Params::builder()
962            .region("us-east-1".to_string())
963            .use_global_endpoint(true)
964            .use_fips(false)
965            .use_dual_stack(false)
966            .accelerate(false)
967            .build()
968            .expect("invalid params");
969        let resolver = crate::config::endpoint::DefaultResolver::new();
970        let endpoint = resolver.resolve_endpoint(&params);
971        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
972        assert_eq!(
973            endpoint,
974            ::aws_smithy_types::endpoint::Endpoint::builder()
975                .url("https://s3.amazonaws.com")
976                .auth_scheme(
977                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
978                        .put("disableDoubleEncoding", true)
979                        .put("signingName", "s3".to_string())
980                        .put("signingRegion", "us-east-1".to_string())
981                )
982                .build()
983        );
984    }
985
986    /// UseGlobalEndpoints=true, region=us-west-2 uses the regional endpoint
987    #[test]
988    fn test_42() {
989        let params = crate::config::endpoint::Params::builder()
990            .region("us-west-2".to_string())
991            .use_global_endpoint(true)
992            .use_fips(false)
993            .use_dual_stack(false)
994            .accelerate(false)
995            .build()
996            .expect("invalid params");
997        let resolver = crate::config::endpoint::DefaultResolver::new();
998        let endpoint = resolver.resolve_endpoint(&params);
999        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com");
1000        assert_eq!(
1001            endpoint,
1002            ::aws_smithy_types::endpoint::Endpoint::builder()
1003                .url("https://s3.us-west-2.amazonaws.com")
1004                .auth_scheme(
1005                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1006                        .put("disableDoubleEncoding", true)
1007                        .put("signingName", "s3".to_string())
1008                        .put("signingRegion", "us-west-2".to_string())
1009                )
1010                .build()
1011        );
1012    }
1013
1014    /// UseGlobalEndpoints=true, region=cn-north-1 uses the regional endpoint
1015    #[test]
1016    fn test_43() {
1017        let params = crate::config::endpoint::Params::builder()
1018            .region("cn-north-1".to_string())
1019            .use_global_endpoint(true)
1020            .use_fips(false)
1021            .use_dual_stack(false)
1022            .accelerate(false)
1023            .build()
1024            .expect("invalid params");
1025        let resolver = crate::config::endpoint::DefaultResolver::new();
1026        let endpoint = resolver.resolve_endpoint(&params);
1027        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn");
1028        assert_eq!(
1029            endpoint,
1030            ::aws_smithy_types::endpoint::Endpoint::builder()
1031                .url("https://s3.cn-north-1.amazonaws.com.cn")
1032                .auth_scheme(
1033                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1034                        .put("disableDoubleEncoding", true)
1035                        .put("signingName", "s3".to_string())
1036                        .put("signingRegion", "cn-north-1".to_string())
1037                )
1038                .build()
1039        );
1040    }
1041
1042    /// UseGlobalEndpoints=true, region=us-east-1, fips=true uses the regional endpoint with fips
1043    #[test]
1044    fn test_44() {
1045        let params = crate::config::endpoint::Params::builder()
1046            .region("us-east-1".to_string())
1047            .use_global_endpoint(true)
1048            .use_fips(true)
1049            .use_dual_stack(false)
1050            .accelerate(false)
1051            .build()
1052            .expect("invalid params");
1053        let resolver = crate::config::endpoint::DefaultResolver::new();
1054        let endpoint = resolver.resolve_endpoint(&params);
1055        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com");
1056        assert_eq!(
1057            endpoint,
1058            ::aws_smithy_types::endpoint::Endpoint::builder()
1059                .url("https://s3-fips.us-east-1.amazonaws.com")
1060                .auth_scheme(
1061                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1062                        .put("disableDoubleEncoding", true)
1063                        .put("signingName", "s3".to_string())
1064                        .put("signingRegion", "us-east-1".to_string())
1065                )
1066                .build()
1067        );
1068    }
1069
1070    /// UseGlobalEndpoints=true, region=us-east-1, dualstack=true uses the regional endpoint with dualstack
1071    #[test]
1072    fn test_45() {
1073        let params = crate::config::endpoint::Params::builder()
1074            .region("us-east-1".to_string())
1075            .use_global_endpoint(true)
1076            .use_fips(false)
1077            .use_dual_stack(true)
1078            .accelerate(false)
1079            .build()
1080            .expect("invalid params");
1081        let resolver = crate::config::endpoint::DefaultResolver::new();
1082        let endpoint = resolver.resolve_endpoint(&params);
1083        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com");
1084        assert_eq!(
1085            endpoint,
1086            ::aws_smithy_types::endpoint::Endpoint::builder()
1087                .url("https://s3.dualstack.us-east-1.amazonaws.com")
1088                .auth_scheme(
1089                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1090                        .put("disableDoubleEncoding", true)
1091                        .put("signingName", "s3".to_string())
1092                        .put("signingRegion", "us-east-1".to_string())
1093                )
1094                .build()
1095        );
1096    }
1097
1098    /// UseGlobalEndpoints=true, region=us-east-1, dualstack and fips uses the regional endpoint with fips/dualstack
1099    #[test]
1100    fn test_46() {
1101        let params = crate::config::endpoint::Params::builder()
1102            .region("us-east-1".to_string())
1103            .use_global_endpoint(true)
1104            .use_fips(true)
1105            .use_dual_stack(true)
1106            .accelerate(false)
1107            .build()
1108            .expect("invalid params");
1109        let resolver = crate::config::endpoint::DefaultResolver::new();
1110        let endpoint = resolver.resolve_endpoint(&params);
1111        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com");
1112        assert_eq!(
1113            endpoint,
1114            ::aws_smithy_types::endpoint::Endpoint::builder()
1115                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com")
1116                .auth_scheme(
1117                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1118                        .put("disableDoubleEncoding", true)
1119                        .put("signingName", "s3".to_string())
1120                        .put("signingRegion", "us-east-1".to_string())
1121                )
1122                .build()
1123        );
1124    }
1125
1126    /// UseGlobalEndpoints=true, region=us-east-1 with custom endpoint, uses custom
1127    #[test]
1128    fn test_47() {
1129        let params = crate::config::endpoint::Params::builder()
1130            .region("us-east-1".to_string())
1131            .endpoint("https://example.com".to_string())
1132            .use_global_endpoint(true)
1133            .use_fips(false)
1134            .use_dual_stack(false)
1135            .accelerate(false)
1136            .build()
1137            .expect("invalid params");
1138        let resolver = crate::config::endpoint::DefaultResolver::new();
1139        let endpoint = resolver.resolve_endpoint(&params);
1140        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1141        assert_eq!(
1142            endpoint,
1143            ::aws_smithy_types::endpoint::Endpoint::builder()
1144                .url("https://example.com")
1145                .auth_scheme(
1146                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1147                        .put("disableDoubleEncoding", true)
1148                        .put("signingName", "s3".to_string())
1149                        .put("signingRegion", "us-east-1".to_string())
1150                )
1151                .build()
1152        );
1153    }
1154
1155    /// UseGlobalEndpoints=true, region=us-west-2 with custom endpoint, uses custom
1156    #[test]
1157    fn test_48() {
1158        let params = crate::config::endpoint::Params::builder()
1159            .region("us-west-2".to_string())
1160            .endpoint("https://example.com".to_string())
1161            .use_global_endpoint(true)
1162            .use_fips(false)
1163            .use_dual_stack(false)
1164            .accelerate(false)
1165            .build()
1166            .expect("invalid params");
1167        let resolver = crate::config::endpoint::DefaultResolver::new();
1168        let endpoint = resolver.resolve_endpoint(&params);
1169        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1170        assert_eq!(
1171            endpoint,
1172            ::aws_smithy_types::endpoint::Endpoint::builder()
1173                .url("https://example.com")
1174                .auth_scheme(
1175                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1176                        .put("disableDoubleEncoding", true)
1177                        .put("signingName", "s3".to_string())
1178                        .put("signingRegion", "us-west-2".to_string())
1179                )
1180                .build()
1181        );
1182    }
1183
1184    /// UseGlobalEndpoints=true, region=us-east-1 with accelerate on non bucket case uses the global endpoint and ignores accelerate
1185    #[test]
1186    fn test_49() {
1187        let params = crate::config::endpoint::Params::builder()
1188            .region("us-east-1".to_string())
1189            .use_global_endpoint(true)
1190            .use_fips(false)
1191            .use_dual_stack(false)
1192            .accelerate(true)
1193            .build()
1194            .expect("invalid params");
1195        let resolver = crate::config::endpoint::DefaultResolver::new();
1196        let endpoint = resolver.resolve_endpoint(&params);
1197        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1198        assert_eq!(
1199            endpoint,
1200            ::aws_smithy_types::endpoint::Endpoint::builder()
1201                .url("https://s3.amazonaws.com")
1202                .auth_scheme(
1203                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1204                        .put("disableDoubleEncoding", true)
1205                        .put("signingName", "s3".to_string())
1206                        .put("signingRegion", "us-east-1".to_string())
1207                )
1208                .build()
1209        );
1210    }
1211
1212    /// aws-global region uses the global endpoint
1213    #[test]
1214    fn test_50() {
1215        let params = crate::config::endpoint::Params::builder()
1216            .region("aws-global".to_string())
1217            .use_fips(false)
1218            .use_dual_stack(false)
1219            .accelerate(false)
1220            .build()
1221            .expect("invalid params");
1222        let resolver = crate::config::endpoint::DefaultResolver::new();
1223        let endpoint = resolver.resolve_endpoint(&params);
1224        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1225        assert_eq!(
1226            endpoint,
1227            ::aws_smithy_types::endpoint::Endpoint::builder()
1228                .url("https://s3.amazonaws.com")
1229                .auth_scheme(
1230                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1231                        .put("disableDoubleEncoding", true)
1232                        .put("signingName", "s3".to_string())
1233                        .put("signingRegion", "us-east-1".to_string())
1234                )
1235                .build()
1236        );
1237    }
1238
1239    /// aws-global region with fips uses the regional endpoint
1240    #[test]
1241    fn test_51() {
1242        let params = crate::config::endpoint::Params::builder()
1243            .region("aws-global".to_string())
1244            .use_fips(true)
1245            .use_dual_stack(false)
1246            .accelerate(false)
1247            .build()
1248            .expect("invalid params");
1249        let resolver = crate::config::endpoint::DefaultResolver::new();
1250        let endpoint = resolver.resolve_endpoint(&params);
1251        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com");
1252        assert_eq!(
1253            endpoint,
1254            ::aws_smithy_types::endpoint::Endpoint::builder()
1255                .url("https://s3-fips.us-east-1.amazonaws.com")
1256                .auth_scheme(
1257                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1258                        .put("disableDoubleEncoding", true)
1259                        .put("signingName", "s3".to_string())
1260                        .put("signingRegion", "us-east-1".to_string())
1261                )
1262                .build()
1263        );
1264    }
1265
1266    /// aws-global region with dualstack uses the regional endpoint
1267    #[test]
1268    fn test_52() {
1269        let params = crate::config::endpoint::Params::builder()
1270            .region("aws-global".to_string())
1271            .use_fips(false)
1272            .use_dual_stack(true)
1273            .accelerate(false)
1274            .build()
1275            .expect("invalid params");
1276        let resolver = crate::config::endpoint::DefaultResolver::new();
1277        let endpoint = resolver.resolve_endpoint(&params);
1278        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com");
1279        assert_eq!(
1280            endpoint,
1281            ::aws_smithy_types::endpoint::Endpoint::builder()
1282                .url("https://s3.dualstack.us-east-1.amazonaws.com")
1283                .auth_scheme(
1284                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1285                        .put("disableDoubleEncoding", true)
1286                        .put("signingName", "s3".to_string())
1287                        .put("signingRegion", "us-east-1".to_string())
1288                )
1289                .build()
1290        );
1291    }
1292
1293    /// aws-global region with fips and dualstack uses the regional endpoint
1294    #[test]
1295    fn test_53() {
1296        let params = crate::config::endpoint::Params::builder()
1297            .region("aws-global".to_string())
1298            .use_fips(true)
1299            .use_dual_stack(true)
1300            .accelerate(false)
1301            .build()
1302            .expect("invalid params");
1303        let resolver = crate::config::endpoint::DefaultResolver::new();
1304        let endpoint = resolver.resolve_endpoint(&params);
1305        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com");
1306        assert_eq!(
1307            endpoint,
1308            ::aws_smithy_types::endpoint::Endpoint::builder()
1309                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com")
1310                .auth_scheme(
1311                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1312                        .put("disableDoubleEncoding", true)
1313                        .put("signingName", "s3".to_string())
1314                        .put("signingRegion", "us-east-1".to_string())
1315                )
1316                .build()
1317        );
1318    }
1319
1320    /// aws-global region with accelerate on non-bucket case, uses global endpoint and ignores accelerate
1321    #[test]
1322    fn test_54() {
1323        let params = crate::config::endpoint::Params::builder()
1324            .region("aws-global".to_string())
1325            .use_fips(false)
1326            .use_dual_stack(false)
1327            .accelerate(true)
1328            .build()
1329            .expect("invalid params");
1330        let resolver = crate::config::endpoint::DefaultResolver::new();
1331        let endpoint = resolver.resolve_endpoint(&params);
1332        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com");
1333        assert_eq!(
1334            endpoint,
1335            ::aws_smithy_types::endpoint::Endpoint::builder()
1336                .url("https://s3.amazonaws.com")
1337                .auth_scheme(
1338                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1339                        .put("disableDoubleEncoding", true)
1340                        .put("signingName", "s3".to_string())
1341                        .put("signingRegion", "us-east-1".to_string())
1342                )
1343                .build()
1344        );
1345    }
1346
1347    /// aws-global region with custom endpoint, uses custom
1348    #[test]
1349    fn test_55() {
1350        let params = crate::config::endpoint::Params::builder()
1351            .region("aws-global".to_string())
1352            .endpoint("https://example.com".to_string())
1353            .use_global_endpoint(false)
1354            .use_fips(false)
1355            .use_dual_stack(false)
1356            .accelerate(false)
1357            .build()
1358            .expect("invalid params");
1359        let resolver = crate::config::endpoint::DefaultResolver::new();
1360        let endpoint = resolver.resolve_endpoint(&params);
1361        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1362        assert_eq!(
1363            endpoint,
1364            ::aws_smithy_types::endpoint::Endpoint::builder()
1365                .url("https://example.com")
1366                .auth_scheme(
1367                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1368                        .put("disableDoubleEncoding", true)
1369                        .put("signingName", "s3".to_string())
1370                        .put("signingRegion", "us-east-1".to_string())
1371                )
1372                .build()
1373        );
1374    }
1375
1376    /// virtual addressing, aws-global region uses the global endpoint
1377    #[test]
1378    fn test_56() {
1379        let params = crate::config::endpoint::Params::builder()
1380            .region("aws-global".to_string())
1381            .bucket("bucket-name".to_string())
1382            .use_fips(false)
1383            .use_dual_stack(false)
1384            .accelerate(false)
1385            .build()
1386            .expect("invalid params");
1387        let resolver = crate::config::endpoint::DefaultResolver::new();
1388        let endpoint = resolver.resolve_endpoint(&params);
1389        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1390        assert_eq!(
1391            endpoint,
1392            ::aws_smithy_types::endpoint::Endpoint::builder()
1393                .url("https://bucket-name.s3.amazonaws.com")
1394                .auth_scheme(
1395                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1396                        .put("disableDoubleEncoding", true)
1397                        .put("signingName", "s3".to_string())
1398                        .put("signingRegion", "us-east-1".to_string())
1399                )
1400                .build()
1401        );
1402    }
1403
1404    /// virtual addressing, aws-global region with Prefix, and Key uses the global endpoint. Prefix and Key parameters should not be used in endpoint evaluation.
1405    #[test]
1406    fn test_57() {
1407        let params = crate::config::endpoint::Params::builder()
1408            .region("aws-global".to_string())
1409            .bucket("bucket-name".to_string())
1410            .use_fips(false)
1411            .use_dual_stack(false)
1412            .accelerate(false)
1413            .prefix("prefix".to_string())
1414            .key("key".to_string())
1415            .build()
1416            .expect("invalid params");
1417        let resolver = crate::config::endpoint::DefaultResolver::new();
1418        let endpoint = resolver.resolve_endpoint(&params);
1419        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1420        assert_eq!(
1421            endpoint,
1422            ::aws_smithy_types::endpoint::Endpoint::builder()
1423                .url("https://bucket-name.s3.amazonaws.com")
1424                .auth_scheme(
1425                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1426                        .put("disableDoubleEncoding", true)
1427                        .put("signingName", "s3".to_string())
1428                        .put("signingRegion", "us-east-1".to_string())
1429                )
1430                .build()
1431        );
1432    }
1433
1434    /// 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.
1435    #[test]
1436    fn test_58() {
1437        let params = crate::config::endpoint::Params::builder()
1438            .region("aws-global".to_string())
1439            .bucket("bucket-name".to_string())
1440            .use_fips(false)
1441            .use_dual_stack(false)
1442            .accelerate(false)
1443            .copy_source("/copy/source".to_string())
1444            .key("key".to_string())
1445            .build()
1446            .expect("invalid params");
1447        let resolver = crate::config::endpoint::DefaultResolver::new();
1448        let endpoint = resolver.resolve_endpoint(&params);
1449        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1450        assert_eq!(
1451            endpoint,
1452            ::aws_smithy_types::endpoint::Endpoint::builder()
1453                .url("https://bucket-name.s3.amazonaws.com")
1454                .auth_scheme(
1455                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1456                        .put("disableDoubleEncoding", true)
1457                        .put("signingName", "s3".to_string())
1458                        .put("signingRegion", "us-east-1".to_string())
1459                )
1460                .build()
1461        );
1462    }
1463
1464    /// virtual addressing, aws-global region with fips uses the regional fips endpoint
1465    #[test]
1466    fn test_59() {
1467        let params = crate::config::endpoint::Params::builder()
1468            .region("aws-global".to_string())
1469            .bucket("bucket-name".to_string())
1470            .use_fips(true)
1471            .use_dual_stack(false)
1472            .accelerate(false)
1473            .build()
1474            .expect("invalid params");
1475        let resolver = crate::config::endpoint::DefaultResolver::new();
1476        let endpoint = resolver.resolve_endpoint(&params);
1477        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-east-1.amazonaws.com");
1478        assert_eq!(
1479            endpoint,
1480            ::aws_smithy_types::endpoint::Endpoint::builder()
1481                .url("https://bucket-name.s3-fips.us-east-1.amazonaws.com")
1482                .auth_scheme(
1483                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1484                        .put("disableDoubleEncoding", true)
1485                        .put("signingName", "s3".to_string())
1486                        .put("signingRegion", "us-east-1".to_string())
1487                )
1488                .build()
1489        );
1490    }
1491
1492    /// virtual addressing, aws-global region with dualstack uses the regional dualstack endpoint
1493    #[test]
1494    fn test_60() {
1495        let params = crate::config::endpoint::Params::builder()
1496            .region("aws-global".to_string())
1497            .bucket("bucket-name".to_string())
1498            .use_fips(false)
1499            .use_dual_stack(true)
1500            .accelerate(false)
1501            .build()
1502            .expect("invalid params");
1503        let resolver = crate::config::endpoint::DefaultResolver::new();
1504        let endpoint = resolver.resolve_endpoint(&params);
1505        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-east-1.amazonaws.com");
1506        assert_eq!(
1507            endpoint,
1508            ::aws_smithy_types::endpoint::Endpoint::builder()
1509                .url("https://bucket-name.s3.dualstack.us-east-1.amazonaws.com")
1510                .auth_scheme(
1511                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1512                        .put("disableDoubleEncoding", true)
1513                        .put("signingName", "s3".to_string())
1514                        .put("signingRegion", "us-east-1".to_string())
1515                )
1516                .build()
1517        );
1518    }
1519
1520    /// virtual addressing, aws-global region with fips/dualstack uses the regional fips/dualstack endpoint
1521    #[test]
1522    fn test_61() {
1523        let params = crate::config::endpoint::Params::builder()
1524            .region("aws-global".to_string())
1525            .bucket("bucket-name".to_string())
1526            .use_fips(true)
1527            .use_dual_stack(true)
1528            .accelerate(false)
1529            .build()
1530            .expect("invalid params");
1531        let resolver = crate::config::endpoint::DefaultResolver::new();
1532        let endpoint = resolver.resolve_endpoint(&params);
1533        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.us-east-1.amazonaws.com");
1534        assert_eq!(
1535            endpoint,
1536            ::aws_smithy_types::endpoint::Endpoint::builder()
1537                .url("https://bucket-name.s3-fips.dualstack.us-east-1.amazonaws.com")
1538                .auth_scheme(
1539                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1540                        .put("disableDoubleEncoding", true)
1541                        .put("signingName", "s3".to_string())
1542                        .put("signingRegion", "us-east-1".to_string())
1543                )
1544                .build()
1545        );
1546    }
1547
1548    /// virtual addressing, aws-global region with accelerate uses the global accelerate endpoint
1549    #[test]
1550    fn test_62() {
1551        let params = crate::config::endpoint::Params::builder()
1552            .region("aws-global".to_string())
1553            .bucket("bucket-name".to_string())
1554            .use_fips(false)
1555            .use_dual_stack(false)
1556            .accelerate(true)
1557            .build()
1558            .expect("invalid params");
1559        let resolver = crate::config::endpoint::DefaultResolver::new();
1560        let endpoint = resolver.resolve_endpoint(&params);
1561        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
1562        assert_eq!(
1563            endpoint,
1564            ::aws_smithy_types::endpoint::Endpoint::builder()
1565                .url("https://bucket-name.s3-accelerate.amazonaws.com")
1566                .auth_scheme(
1567                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1568                        .put("disableDoubleEncoding", true)
1569                        .put("signingName", "s3".to_string())
1570                        .put("signingRegion", "us-east-1".to_string())
1571                )
1572                .build()
1573        );
1574    }
1575
1576    /// virtual addressing, aws-global region with custom endpoint
1577    #[test]
1578    fn test_63() {
1579        let params = crate::config::endpoint::Params::builder()
1580            .region("aws-global".to_string())
1581            .endpoint("https://example.com".to_string())
1582            .bucket("bucket-name".to_string())
1583            .use_fips(false)
1584            .use_dual_stack(false)
1585            .accelerate(false)
1586            .build()
1587            .expect("invalid params");
1588        let resolver = crate::config::endpoint::DefaultResolver::new();
1589        let endpoint = resolver.resolve_endpoint(&params);
1590        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.example.com");
1591        assert_eq!(
1592            endpoint,
1593            ::aws_smithy_types::endpoint::Endpoint::builder()
1594                .url("https://bucket-name.example.com")
1595                .auth_scheme(
1596                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1597                        .put("disableDoubleEncoding", true)
1598                        .put("signingName", "s3".to_string())
1599                        .put("signingRegion", "us-east-1".to_string())
1600                )
1601                .build()
1602        );
1603    }
1604
1605    /// virtual addressing, UseGlobalEndpoint and us-east-1 region uses the global endpoint
1606    #[test]
1607    fn test_64() {
1608        let params = crate::config::endpoint::Params::builder()
1609            .region("us-east-1".to_string())
1610            .use_global_endpoint(true)
1611            .bucket("bucket-name".to_string())
1612            .use_fips(false)
1613            .use_dual_stack(false)
1614            .accelerate(false)
1615            .build()
1616            .expect("invalid params");
1617        let resolver = crate::config::endpoint::DefaultResolver::new();
1618        let endpoint = resolver.resolve_endpoint(&params);
1619        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.amazonaws.com");
1620        assert_eq!(
1621            endpoint,
1622            ::aws_smithy_types::endpoint::Endpoint::builder()
1623                .url("https://bucket-name.s3.amazonaws.com")
1624                .auth_scheme(
1625                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1626                        .put("disableDoubleEncoding", true)
1627                        .put("signingName", "s3".to_string())
1628                        .put("signingRegion", "us-east-1".to_string())
1629                )
1630                .build()
1631        );
1632    }
1633
1634    /// virtual addressing, UseGlobalEndpoint and us-west-2 region uses the regional endpoint
1635    #[test]
1636    fn test_65() {
1637        let params = crate::config::endpoint::Params::builder()
1638            .region("us-west-2".to_string())
1639            .use_global_endpoint(true)
1640            .bucket("bucket-name".to_string())
1641            .use_fips(false)
1642            .use_dual_stack(false)
1643            .accelerate(false)
1644            .build()
1645            .expect("invalid params");
1646        let resolver = crate::config::endpoint::DefaultResolver::new();
1647        let endpoint = resolver.resolve_endpoint(&params);
1648        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.us-west-2.amazonaws.com");
1649        assert_eq!(
1650            endpoint,
1651            ::aws_smithy_types::endpoint::Endpoint::builder()
1652                .url("https://bucket-name.s3.us-west-2.amazonaws.com")
1653                .auth_scheme(
1654                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1655                        .put("disableDoubleEncoding", true)
1656                        .put("signingName", "s3".to_string())
1657                        .put("signingRegion", "us-west-2".to_string())
1658                )
1659                .build()
1660        );
1661    }
1662
1663    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and fips uses the regional fips endpoint
1664    #[test]
1665    fn test_66() {
1666        let params = crate::config::endpoint::Params::builder()
1667            .region("us-east-1".to_string())
1668            .use_global_endpoint(true)
1669            .bucket("bucket-name".to_string())
1670            .use_fips(true)
1671            .use_dual_stack(false)
1672            .accelerate(false)
1673            .build()
1674            .expect("invalid params");
1675        let resolver = crate::config::endpoint::DefaultResolver::new();
1676        let endpoint = resolver.resolve_endpoint(&params);
1677        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-east-1.amazonaws.com");
1678        assert_eq!(
1679            endpoint,
1680            ::aws_smithy_types::endpoint::Endpoint::builder()
1681                .url("https://bucket-name.s3-fips.us-east-1.amazonaws.com")
1682                .auth_scheme(
1683                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1684                        .put("disableDoubleEncoding", true)
1685                        .put("signingName", "s3".to_string())
1686                        .put("signingRegion", "us-east-1".to_string())
1687                )
1688                .build()
1689        );
1690    }
1691
1692    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and dualstack uses the regional dualstack endpoint
1693    #[test]
1694    fn test_67() {
1695        let params = crate::config::endpoint::Params::builder()
1696            .region("us-east-1".to_string())
1697            .use_global_endpoint(true)
1698            .bucket("bucket-name".to_string())
1699            .use_fips(false)
1700            .use_dual_stack(true)
1701            .accelerate(false)
1702            .build()
1703            .expect("invalid params");
1704        let resolver = crate::config::endpoint::DefaultResolver::new();
1705        let endpoint = resolver.resolve_endpoint(&params);
1706        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-east-1.amazonaws.com");
1707        assert_eq!(
1708            endpoint,
1709            ::aws_smithy_types::endpoint::Endpoint::builder()
1710                .url("https://bucket-name.s3.dualstack.us-east-1.amazonaws.com")
1711                .auth_scheme(
1712                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1713                        .put("disableDoubleEncoding", true)
1714                        .put("signingName", "s3".to_string())
1715                        .put("signingRegion", "us-east-1".to_string())
1716                )
1717                .build()
1718        );
1719    }
1720
1721    /// virtual addressing, UseGlobalEndpoint and us-east-1 region and accelerate uses the global accelerate endpoint
1722    #[test]
1723    fn test_68() {
1724        let params = crate::config::endpoint::Params::builder()
1725            .region("us-east-1".to_string())
1726            .use_global_endpoint(true)
1727            .bucket("bucket-name".to_string())
1728            .use_fips(false)
1729            .use_dual_stack(false)
1730            .accelerate(true)
1731            .build()
1732            .expect("invalid params");
1733        let resolver = crate::config::endpoint::DefaultResolver::new();
1734        let endpoint = resolver.resolve_endpoint(&params);
1735        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
1736        assert_eq!(
1737            endpoint,
1738            ::aws_smithy_types::endpoint::Endpoint::builder()
1739                .url("https://bucket-name.s3-accelerate.amazonaws.com")
1740                .auth_scheme(
1741                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1742                        .put("disableDoubleEncoding", true)
1743                        .put("signingName", "s3".to_string())
1744                        .put("signingRegion", "us-east-1".to_string())
1745                )
1746                .build()
1747        );
1748    }
1749
1750    /// virtual addressing, UseGlobalEndpoint and us-east-1 region with custom endpoint
1751    #[test]
1752    fn test_69() {
1753        let params = crate::config::endpoint::Params::builder()
1754            .region("us-east-1".to_string())
1755            .endpoint("https://example.com".to_string())
1756            .use_global_endpoint(true)
1757            .bucket("bucket-name".to_string())
1758            .use_fips(false)
1759            .use_dual_stack(false)
1760            .accelerate(false)
1761            .build()
1762            .expect("invalid params");
1763        let resolver = crate::config::endpoint::DefaultResolver::new();
1764        let endpoint = resolver.resolve_endpoint(&params);
1765        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.example.com");
1766        assert_eq!(
1767            endpoint,
1768            ::aws_smithy_types::endpoint::Endpoint::builder()
1769                .url("https://bucket-name.example.com")
1770                .auth_scheme(
1771                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1772                        .put("disableDoubleEncoding", true)
1773                        .put("signingName", "s3".to_string())
1774                        .put("signingRegion", "us-east-1".to_string())
1775                )
1776                .build()
1777        );
1778    }
1779
1780    /// ForcePathStyle, aws-global region uses the global endpoint
1781    #[test]
1782    fn test_70() {
1783        let params = crate::config::endpoint::Params::builder()
1784            .region("aws-global".to_string())
1785            .bucket("bucket-name".to_string())
1786            .force_path_style(true)
1787            .use_fips(false)
1788            .use_dual_stack(false)
1789            .accelerate(false)
1790            .build()
1791            .expect("invalid params");
1792        let resolver = crate::config::endpoint::DefaultResolver::new();
1793        let endpoint = resolver.resolve_endpoint(&params);
1794        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket-name");
1795        assert_eq!(
1796            endpoint,
1797            ::aws_smithy_types::endpoint::Endpoint::builder()
1798                .url("https://s3.amazonaws.com/bucket-name")
1799                .auth_scheme(
1800                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1801                        .put("disableDoubleEncoding", true)
1802                        .put("signingName", "s3".to_string())
1803                        .put("signingRegion", "us-east-1".to_string())
1804                )
1805                .build()
1806        );
1807    }
1808
1809    /// ForcePathStyle, aws-global region with fips is invalid
1810    #[test]
1811    fn test_71() {
1812        let params = crate::config::endpoint::Params::builder()
1813            .region("aws-global".to_string())
1814            .bucket("bucket-name".to_string())
1815            .force_path_style(true)
1816            .use_fips(true)
1817            .use_dual_stack(false)
1818            .accelerate(false)
1819            .build()
1820            .expect("invalid params");
1821        let resolver = crate::config::endpoint::DefaultResolver::new();
1822        let endpoint = resolver.resolve_endpoint(&params);
1823        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket-name");
1824        assert_eq!(
1825            endpoint,
1826            ::aws_smithy_types::endpoint::Endpoint::builder()
1827                .url("https://s3-fips.us-east-1.amazonaws.com/bucket-name")
1828                .auth_scheme(
1829                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1830                        .put("disableDoubleEncoding", true)
1831                        .put("signingName", "s3".to_string())
1832                        .put("signingRegion", "us-east-1".to_string())
1833                )
1834                .build()
1835        );
1836    }
1837
1838    /// ForcePathStyle, aws-global region with dualstack uses regional dualstack endpoint
1839    #[test]
1840    fn test_72() {
1841        let params = crate::config::endpoint::Params::builder()
1842            .region("aws-global".to_string())
1843            .bucket("bucket-name".to_string())
1844            .force_path_style(true)
1845            .use_fips(false)
1846            .use_dual_stack(true)
1847            .accelerate(false)
1848            .build()
1849            .expect("invalid params");
1850        let resolver = crate::config::endpoint::DefaultResolver::new();
1851        let endpoint = resolver.resolve_endpoint(&params);
1852        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket-name");
1853        assert_eq!(
1854            endpoint,
1855            ::aws_smithy_types::endpoint::Endpoint::builder()
1856                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket-name")
1857                .auth_scheme(
1858                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1859                        .put("disableDoubleEncoding", true)
1860                        .put("signingName", "s3".to_string())
1861                        .put("signingRegion", "us-east-1".to_string())
1862                )
1863                .build()
1864        );
1865    }
1866
1867    /// ForcePathStyle, aws-global region custom endpoint uses the custom endpoint
1868    #[test]
1869    fn test_73() {
1870        let params = crate::config::endpoint::Params::builder()
1871            .region("aws-global".to_string())
1872            .endpoint("https://example.com".to_string())
1873            .bucket("bucket-name".to_string())
1874            .force_path_style(true)
1875            .use_fips(false)
1876            .use_dual_stack(false)
1877            .accelerate(false)
1878            .build()
1879            .expect("invalid params");
1880        let resolver = crate::config::endpoint::DefaultResolver::new();
1881        let endpoint = resolver.resolve_endpoint(&params);
1882        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com/bucket-name");
1883        assert_eq!(
1884            endpoint,
1885            ::aws_smithy_types::endpoint::Endpoint::builder()
1886                .url("https://example.com/bucket-name")
1887                .auth_scheme(
1888                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1889                        .put("disableDoubleEncoding", true)
1890                        .put("signingName", "s3".to_string())
1891                        .put("signingRegion", "us-east-1".to_string())
1892                )
1893                .build()
1894        );
1895    }
1896
1897    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region uses the global endpoint
1898    #[test]
1899    fn test_74() {
1900        let params = crate::config::endpoint::Params::builder()
1901            .region("us-east-1".to_string())
1902            .bucket("bucket-name".to_string())
1903            .use_global_endpoint(true)
1904            .force_path_style(true)
1905            .use_fips(false)
1906            .use_dual_stack(false)
1907            .accelerate(false)
1908            .build()
1909            .expect("invalid params");
1910        let resolver = crate::config::endpoint::DefaultResolver::new();
1911        let endpoint = resolver.resolve_endpoint(&params);
1912        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket-name");
1913        assert_eq!(
1914            endpoint,
1915            ::aws_smithy_types::endpoint::Endpoint::builder()
1916                .url("https://s3.amazonaws.com/bucket-name")
1917                .auth_scheme(
1918                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1919                        .put("disableDoubleEncoding", true)
1920                        .put("signingName", "s3".to_string())
1921                        .put("signingRegion", "us-east-1".to_string())
1922                )
1923                .build()
1924        );
1925    }
1926
1927    /// ForcePathStyle, UseGlobalEndpoint us-west-2 region uses the regional endpoint
1928    #[test]
1929    fn test_75() {
1930        let params = crate::config::endpoint::Params::builder()
1931            .region("us-west-2".to_string())
1932            .bucket("bucket-name".to_string())
1933            .use_global_endpoint(true)
1934            .force_path_style(true)
1935            .use_fips(false)
1936            .use_dual_stack(false)
1937            .accelerate(false)
1938            .build()
1939            .expect("invalid params");
1940        let resolver = crate::config::endpoint::DefaultResolver::new();
1941        let endpoint = resolver.resolve_endpoint(&params);
1942        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket-name");
1943        assert_eq!(
1944            endpoint,
1945            ::aws_smithy_types::endpoint::Endpoint::builder()
1946                .url("https://s3.us-west-2.amazonaws.com/bucket-name")
1947                .auth_scheme(
1948                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1949                        .put("disableDoubleEncoding", true)
1950                        .put("signingName", "s3".to_string())
1951                        .put("signingRegion", "us-west-2".to_string())
1952                )
1953                .build()
1954        );
1955    }
1956
1957    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region, dualstack uses the regional dualstack endpoint
1958    #[test]
1959    fn test_76() {
1960        let params = crate::config::endpoint::Params::builder()
1961            .region("us-east-1".to_string())
1962            .bucket("bucket-name".to_string())
1963            .use_global_endpoint(true)
1964            .force_path_style(true)
1965            .use_fips(false)
1966            .use_dual_stack(true)
1967            .accelerate(false)
1968            .build()
1969            .expect("invalid params");
1970        let resolver = crate::config::endpoint::DefaultResolver::new();
1971        let endpoint = resolver.resolve_endpoint(&params);
1972        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket-name");
1973        assert_eq!(
1974            endpoint,
1975            ::aws_smithy_types::endpoint::Endpoint::builder()
1976                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket-name")
1977                .auth_scheme(
1978                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
1979                        .put("disableDoubleEncoding", true)
1980                        .put("signingName", "s3".to_string())
1981                        .put("signingRegion", "us-east-1".to_string())
1982                )
1983                .build()
1984        );
1985    }
1986
1987    /// ForcePathStyle, UseGlobalEndpoint us-east-1 region custom endpoint uses the custom endpoint
1988    #[test]
1989    fn test_77() {
1990        let params = crate::config::endpoint::Params::builder()
1991            .region("us-east-1".to_string())
1992            .bucket("bucket-name".to_string())
1993            .endpoint("https://example.com".to_string())
1994            .use_global_endpoint(true)
1995            .force_path_style(true)
1996            .use_fips(false)
1997            .use_dual_stack(false)
1998            .accelerate(false)
1999            .build()
2000            .expect("invalid params");
2001        let resolver = crate::config::endpoint::DefaultResolver::new();
2002        let endpoint = resolver.resolve_endpoint(&params);
2003        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com/bucket-name");
2004        assert_eq!(
2005            endpoint,
2006            ::aws_smithy_types::endpoint::Endpoint::builder()
2007                .url("https://example.com/bucket-name")
2008                .auth_scheme(
2009                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2010                        .put("disableDoubleEncoding", true)
2011                        .put("signingName", "s3".to_string())
2012                        .put("signingRegion", "us-east-1".to_string())
2013                )
2014                .build()
2015        );
2016    }
2017
2018    /// ARN with aws-global region and  UseArnRegion uses the regional endpoint
2019    #[test]
2020    fn test_78() {
2021        let params = crate::config::endpoint::Params::builder()
2022            .region("aws-global".to_string())
2023            .use_arn_region(true)
2024            .use_fips(false)
2025            .use_dual_stack(false)
2026            .accelerate(false)
2027            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
2028            .build()
2029            .expect("invalid params");
2030        let resolver = crate::config::endpoint::DefaultResolver::new();
2031        let endpoint = resolver.resolve_endpoint(&params);
2032        let endpoint =
2033            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
2034        assert_eq!(
2035            endpoint,
2036            ::aws_smithy_types::endpoint::Endpoint::builder()
2037                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
2038                .auth_scheme(
2039                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
2040                        .put("disableDoubleEncoding", true)
2041                        .put("signingName", "s3-outposts".to_string())
2042                        .put("signingRegionSet", vec!["*".to_string().into()])
2043                )
2044                .auth_scheme(
2045                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2046                        .put("disableDoubleEncoding", true)
2047                        .put("signingName", "s3-outposts".to_string())
2048                        .put("signingRegion", "us-east-1".to_string())
2049                )
2050                .build()
2051        );
2052    }
2053
2054    /// cross partition MRAP ARN is an error
2055    #[test]
2056    fn test_79() {
2057        let params = crate::config::endpoint::Params::builder()
2058            .bucket("arn:aws-cn:s3::123456789012:accesspoint:mfzwi23gnjvgw.mrap".to_string())
2059            .region("us-west-1".to_string())
2060            .build()
2061            .expect("invalid params");
2062        let resolver = crate::config::endpoint::DefaultResolver::new();
2063        let endpoint = resolver.resolve_endpoint(&params);
2064        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]");
2065        assert_eq!(
2066            format!("{}", error),
2067            "Client was configured for partition `aws` but bucket referred to partition `aws-cn`"
2068        )
2069    }
2070
2071    /// Endpoint override, accesspoint with HTTP, port
2072    #[test]
2073    fn test_80() {
2074        let params = crate::config::endpoint::Params::builder()
2075            .endpoint("http://beta.example.com:1234".to_string())
2076            .region("us-west-2".to_string())
2077            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
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: http://myendpoint-123456789012.beta.example.com:1234");
2083        assert_eq!(
2084            endpoint,
2085            ::aws_smithy_types::endpoint::Endpoint::builder()
2086                .url("http://myendpoint-123456789012.beta.example.com:1234")
2087                .auth_scheme(
2088                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2089                        .put("disableDoubleEncoding", true)
2090                        .put("signingName", "s3".to_string())
2091                        .put("signingRegion", "us-west-2".to_string())
2092                )
2093                .build()
2094        );
2095    }
2096
2097    /// Endpoint override, accesspoint with http, path, query, and port
2098    #[test]
2099    fn test_81() {
2100        let params = crate::config::endpoint::Params::builder()
2101            .region("us-west-2".to_string())
2102            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
2103            .endpoint("http://beta.example.com:1234/path".to_string())
2104            .use_fips(false)
2105            .use_dual_stack(false)
2106            .accelerate(false)
2107            .build()
2108            .expect("invalid params");
2109        let resolver = crate::config::endpoint::DefaultResolver::new();
2110        let endpoint = resolver.resolve_endpoint(&params);
2111        let endpoint = endpoint.expect("Expected valid endpoint: http://myendpoint-123456789012.beta.example.com:1234/path");
2112        assert_eq!(
2113            endpoint,
2114            ::aws_smithy_types::endpoint::Endpoint::builder()
2115                .url("http://myendpoint-123456789012.beta.example.com:1234/path")
2116                .auth_scheme(
2117                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2118                        .put("disableDoubleEncoding", true)
2119                        .put("signingName", "s3".to_string())
2120                        .put("signingRegion", "us-west-2".to_string())
2121                )
2122                .build()
2123        );
2124    }
2125
2126    /// non-bucket endpoint override with FIPS = error
2127    #[test]
2128    fn test_82() {
2129        let params = crate::config::endpoint::Params::builder()
2130            .region("us-west-2".to_string())
2131            .endpoint("http://beta.example.com:1234/path".to_string())
2132            .use_fips(true)
2133            .use_dual_stack(false)
2134            .build()
2135            .expect("invalid params");
2136        let resolver = crate::config::endpoint::DefaultResolver::new();
2137        let endpoint = resolver.resolve_endpoint(&params);
2138        let error =
2139            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [non-bucket endpoint override with FIPS = error]");
2140        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2141    }
2142
2143    /// FIPS + dualstack + custom endpoint
2144    #[test]
2145    fn test_83() {
2146        let params = crate::config::endpoint::Params::builder()
2147            .region("us-west-2".to_string())
2148            .endpoint("http://beta.example.com:1234/path".to_string())
2149            .use_fips(true)
2150            .use_dual_stack(true)
2151            .build()
2152            .expect("invalid params");
2153        let resolver = crate::config::endpoint::DefaultResolver::new();
2154        let endpoint = resolver.resolve_endpoint(&params);
2155        let error =
2156            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [FIPS + dualstack + custom endpoint]");
2157        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
2158    }
2159
2160    /// dualstack + custom endpoint
2161    #[test]
2162    fn test_84() {
2163        let params = crate::config::endpoint::Params::builder()
2164            .region("us-west-2".to_string())
2165            .endpoint("http://beta.example.com:1234/path".to_string())
2166            .use_fips(false)
2167            .use_dual_stack(true)
2168            .build()
2169            .expect("invalid params");
2170        let resolver = crate::config::endpoint::DefaultResolver::new();
2171        let endpoint = resolver.resolve_endpoint(&params);
2172        let error = endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [dualstack + custom endpoint]");
2173        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
2174    }
2175
2176    /// custom endpoint without FIPS/dualstack
2177    #[test]
2178    fn test_85() {
2179        let params = crate::config::endpoint::Params::builder()
2180            .region("us-west-2".to_string())
2181            .endpoint("http://beta.example.com:1234/path".to_string())
2182            .use_fips(false)
2183            .use_dual_stack(false)
2184            .build()
2185            .expect("invalid params");
2186        let resolver = crate::config::endpoint::DefaultResolver::new();
2187        let endpoint = resolver.resolve_endpoint(&params);
2188        let endpoint = endpoint.expect("Expected valid endpoint: http://beta.example.com:1234/path");
2189        assert_eq!(
2190            endpoint,
2191            ::aws_smithy_types::endpoint::Endpoint::builder()
2192                .url("http://beta.example.com:1234/path")
2193                .auth_scheme(
2194                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2195                        .put("disableDoubleEncoding", true)
2196                        .put("signingName", "s3".to_string())
2197                        .put("signingRegion", "us-west-2".to_string())
2198                )
2199                .build()
2200        );
2201    }
2202
2203    /// s3 object lambda with access points disabled
2204    #[test]
2205    fn test_86() {
2206        let params = crate::config::endpoint::Params::builder()
2207            .region("us-west-2".to_string())
2208            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:myendpoint".to_string())
2209            .disable_access_points(true)
2210            .build()
2211            .expect("invalid params");
2212        let resolver = crate::config::endpoint::DefaultResolver::new();
2213        let endpoint = resolver.resolve_endpoint(&params);
2214        let error =
2215            endpoint.expect_err("expected error: Access points are not supported for this operation [s3 object lambda with access points disabled]");
2216        assert_eq!(format!("{}", error), "Access points are not supported for this operation")
2217    }
2218
2219    /// non bucket + FIPS
2220    #[test]
2221    fn test_87() {
2222        let params = crate::config::endpoint::Params::builder()
2223            .region("us-west-2".to_string())
2224            .use_fips(true)
2225            .use_dual_stack(false)
2226            .build()
2227            .expect("invalid params");
2228        let resolver = crate::config::endpoint::DefaultResolver::new();
2229        let endpoint = resolver.resolve_endpoint(&params);
2230        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-west-2.amazonaws.com");
2231        assert_eq!(
2232            endpoint,
2233            ::aws_smithy_types::endpoint::Endpoint::builder()
2234                .url("https://s3-fips.us-west-2.amazonaws.com")
2235                .auth_scheme(
2236                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2237                        .put("disableDoubleEncoding", true)
2238                        .put("signingName", "s3".to_string())
2239                        .put("signingRegion", "us-west-2".to_string())
2240                )
2241                .build()
2242        );
2243    }
2244
2245    /// standard non bucket endpoint
2246    #[test]
2247    fn test_88() {
2248        let params = crate::config::endpoint::Params::builder()
2249            .region("us-west-2".to_string())
2250            .use_fips(false)
2251            .use_dual_stack(false)
2252            .build()
2253            .expect("invalid params");
2254        let resolver = crate::config::endpoint::DefaultResolver::new();
2255        let endpoint = resolver.resolve_endpoint(&params);
2256        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com");
2257        assert_eq!(
2258            endpoint,
2259            ::aws_smithy_types::endpoint::Endpoint::builder()
2260                .url("https://s3.us-west-2.amazonaws.com")
2261                .auth_scheme(
2262                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2263                        .put("disableDoubleEncoding", true)
2264                        .put("signingName", "s3".to_string())
2265                        .put("signingRegion", "us-west-2".to_string())
2266                )
2267                .build()
2268        );
2269    }
2270
2271    /// non bucket endpoint with FIPS + Dualstack
2272    #[test]
2273    fn test_89() {
2274        let params = crate::config::endpoint::Params::builder()
2275            .region("us-west-2".to_string())
2276            .use_fips(true)
2277            .use_dual_stack(true)
2278            .build()
2279            .expect("invalid params");
2280        let resolver = crate::config::endpoint::DefaultResolver::new();
2281        let endpoint = resolver.resolve_endpoint(&params);
2282        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-west-2.amazonaws.com");
2283        assert_eq!(
2284            endpoint,
2285            ::aws_smithy_types::endpoint::Endpoint::builder()
2286                .url("https://s3-fips.dualstack.us-west-2.amazonaws.com")
2287                .auth_scheme(
2288                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2289                        .put("disableDoubleEncoding", true)
2290                        .put("signingName", "s3".to_string())
2291                        .put("signingRegion", "us-west-2".to_string())
2292                )
2293                .build()
2294        );
2295    }
2296
2297    /// non bucket endpoint with dualstack
2298    #[test]
2299    fn test_90() {
2300        let params = crate::config::endpoint::Params::builder()
2301            .region("us-west-2".to_string())
2302            .use_fips(false)
2303            .use_dual_stack(true)
2304            .build()
2305            .expect("invalid params");
2306        let resolver = crate::config::endpoint::DefaultResolver::new();
2307        let endpoint = resolver.resolve_endpoint(&params);
2308        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com");
2309        assert_eq!(
2310            endpoint,
2311            ::aws_smithy_types::endpoint::Endpoint::builder()
2312                .url("https://s3.dualstack.us-west-2.amazonaws.com")
2313                .auth_scheme(
2314                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2315                        .put("disableDoubleEncoding", true)
2316                        .put("signingName", "s3".to_string())
2317                        .put("signingRegion", "us-west-2".to_string())
2318                )
2319                .build()
2320        );
2321    }
2322
2323    /// use global endpoint + IP address endpoint override
2324    #[test]
2325    fn test_91() {
2326        let params = crate::config::endpoint::Params::builder()
2327            .region("us-east-1".to_string())
2328            .bucket("bucket".to_string())
2329            .use_fips(false)
2330            .use_dual_stack(false)
2331            .endpoint("http://127.0.0.1".to_string())
2332            .use_global_endpoint(true)
2333            .build()
2334            .expect("invalid params");
2335        let resolver = crate::config::endpoint::DefaultResolver::new();
2336        let endpoint = resolver.resolve_endpoint(&params);
2337        let endpoint = endpoint.expect("Expected valid endpoint: http://127.0.0.1/bucket");
2338        assert_eq!(
2339            endpoint,
2340            ::aws_smithy_types::endpoint::Endpoint::builder()
2341                .url("http://127.0.0.1/bucket")
2342                .auth_scheme(
2343                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2344                        .put("disableDoubleEncoding", true)
2345                        .put("signingName", "s3".to_string())
2346                        .put("signingRegion", "us-east-1".to_string())
2347                )
2348                .build()
2349        );
2350    }
2351
2352    /// non-dns endpoint + global endpoint
2353    #[test]
2354    fn test_92() {
2355        let params = crate::config::endpoint::Params::builder()
2356            .region("us-east-1".to_string())
2357            .bucket("bucket!".to_string())
2358            .use_fips(false)
2359            .use_dual_stack(false)
2360            .use_global_endpoint(true)
2361            .build()
2362            .expect("invalid params");
2363        let resolver = crate::config::endpoint::DefaultResolver::new();
2364        let endpoint = resolver.resolve_endpoint(&params);
2365        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket%21");
2366        assert_eq!(
2367            endpoint,
2368            ::aws_smithy_types::endpoint::Endpoint::builder()
2369                .url("https://s3.amazonaws.com/bucket%21")
2370                .auth_scheme(
2371                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2372                        .put("disableDoubleEncoding", true)
2373                        .put("signingName", "s3".to_string())
2374                        .put("signingRegion", "us-east-1".to_string())
2375                )
2376                .build()
2377        );
2378    }
2379
2380    /// endpoint override + use global endpoint
2381    #[test]
2382    fn test_93() {
2383        let params = crate::config::endpoint::Params::builder()
2384            .region("us-east-1".to_string())
2385            .bucket("bucket!".to_string())
2386            .use_fips(false)
2387            .use_dual_stack(false)
2388            .use_global_endpoint(true)
2389            .endpoint("http://foo.com".to_string())
2390            .build()
2391            .expect("invalid params");
2392        let resolver = crate::config::endpoint::DefaultResolver::new();
2393        let endpoint = resolver.resolve_endpoint(&params);
2394        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
2395        assert_eq!(
2396            endpoint,
2397            ::aws_smithy_types::endpoint::Endpoint::builder()
2398                .url("http://foo.com/bucket%21")
2399                .auth_scheme(
2400                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2401                        .put("disableDoubleEncoding", true)
2402                        .put("signingName", "s3".to_string())
2403                        .put("signingRegion", "us-east-1".to_string())
2404                )
2405                .build()
2406        );
2407    }
2408
2409    /// FIPS + dualstack + non-bucket endpoint
2410    #[test]
2411    fn test_94() {
2412        let params = crate::config::endpoint::Params::builder()
2413            .region("us-east-1".to_string())
2414            .bucket("bucket!".to_string())
2415            .use_fips(true)
2416            .use_dual_stack(true)
2417            .build()
2418            .expect("invalid params");
2419        let resolver = crate::config::endpoint::DefaultResolver::new();
2420        let endpoint = resolver.resolve_endpoint(&params);
2421        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
2422        assert_eq!(
2423            endpoint,
2424            ::aws_smithy_types::endpoint::Endpoint::builder()
2425                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
2426                .auth_scheme(
2427                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2428                        .put("disableDoubleEncoding", true)
2429                        .put("signingName", "s3".to_string())
2430                        .put("signingRegion", "us-east-1".to_string())
2431                )
2432                .build()
2433        );
2434    }
2435
2436    /// FIPS + dualstack + non-DNS endpoint
2437    #[test]
2438    fn test_95() {
2439        let params = crate::config::endpoint::Params::builder()
2440            .region("us-east-1".to_string())
2441            .bucket("bucket!".to_string())
2442            .force_path_style(true)
2443            .use_fips(true)
2444            .use_dual_stack(true)
2445            .build()
2446            .expect("invalid params");
2447        let resolver = crate::config::endpoint::DefaultResolver::new();
2448        let endpoint = resolver.resolve_endpoint(&params);
2449        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
2450        assert_eq!(
2451            endpoint,
2452            ::aws_smithy_types::endpoint::Endpoint::builder()
2453                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
2454                .auth_scheme(
2455                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2456                        .put("disableDoubleEncoding", true)
2457                        .put("signingName", "s3".to_string())
2458                        .put("signingRegion", "us-east-1".to_string())
2459                )
2460                .build()
2461        );
2462    }
2463
2464    /// endpoint override + FIPS + dualstack (BUG)
2465    #[test]
2466    fn test_96() {
2467        let params = crate::config::endpoint::Params::builder()
2468            .region("us-east-1".to_string())
2469            .bucket("bucket!".to_string())
2470            .force_path_style(true)
2471            .use_fips(true)
2472            .use_dual_stack(false)
2473            .endpoint("http://foo.com".to_string())
2474            .build()
2475            .expect("invalid params");
2476        let resolver = crate::config::endpoint::DefaultResolver::new();
2477        let endpoint = resolver.resolve_endpoint(&params);
2478        let error =
2479            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [endpoint override + FIPS + dualstack (BUG)]");
2480        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2481    }
2482
2483    /// endpoint override + non-dns bucket + FIPS (BUG)
2484    #[test]
2485    fn test_97() {
2486        let params = crate::config::endpoint::Params::builder()
2487            .region("us-east-1".to_string())
2488            .bucket("bucket!".to_string())
2489            .use_fips(true)
2490            .use_dual_stack(false)
2491            .endpoint("http://foo.com".to_string())
2492            .build()
2493            .expect("invalid params");
2494        let resolver = crate::config::endpoint::DefaultResolver::new();
2495        let endpoint = resolver.resolve_endpoint(&params);
2496        let error =
2497            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [endpoint override + non-dns bucket + FIPS (BUG)]");
2498        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2499    }
2500
2501    /// FIPS + bucket endpoint + force path style
2502    #[test]
2503    fn test_98() {
2504        let params = crate::config::endpoint::Params::builder()
2505            .region("us-east-1".to_string())
2506            .bucket("bucket!".to_string())
2507            .force_path_style(true)
2508            .use_fips(true)
2509            .use_dual_stack(false)
2510            .use_global_endpoint(true)
2511            .build()
2512            .expect("invalid params");
2513        let resolver = crate::config::endpoint::DefaultResolver::new();
2514        let endpoint = resolver.resolve_endpoint(&params);
2515        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
2516        assert_eq!(
2517            endpoint,
2518            ::aws_smithy_types::endpoint::Endpoint::builder()
2519                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
2520                .auth_scheme(
2521                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2522                        .put("disableDoubleEncoding", true)
2523                        .put("signingName", "s3".to_string())
2524                        .put("signingRegion", "us-east-1".to_string())
2525                )
2526                .build()
2527        );
2528    }
2529
2530    /// bucket + FIPS + force path style
2531    #[test]
2532    fn test_99() {
2533        let params = crate::config::endpoint::Params::builder()
2534            .region("us-east-1".to_string())
2535            .bucket("bucket".to_string())
2536            .force_path_style(true)
2537            .use_fips(true)
2538            .use_dual_stack(true)
2539            .use_global_endpoint(true)
2540            .build()
2541            .expect("invalid params");
2542        let resolver = crate::config::endpoint::DefaultResolver::new();
2543        let endpoint = resolver.resolve_endpoint(&params);
2544        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket");
2545        assert_eq!(
2546            endpoint,
2547            ::aws_smithy_types::endpoint::Endpoint::builder()
2548                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket")
2549                .auth_scheme(
2550                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2551                        .put("disableDoubleEncoding", true)
2552                        .put("signingName", "s3".to_string())
2553                        .put("signingRegion", "us-east-1".to_string())
2554                )
2555                .build()
2556        );
2557    }
2558
2559    /// FIPS + dualstack + use global endpoint
2560    #[test]
2561    fn test_100() {
2562        let params = crate::config::endpoint::Params::builder()
2563            .region("us-east-1".to_string())
2564            .bucket("bucket".to_string())
2565            .use_fips(true)
2566            .use_dual_stack(true)
2567            .use_global_endpoint(true)
2568            .build()
2569            .expect("invalid params");
2570        let resolver = crate::config::endpoint::DefaultResolver::new();
2571        let endpoint = resolver.resolve_endpoint(&params);
2572        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-fips.dualstack.us-east-1.amazonaws.com");
2573        assert_eq!(
2574            endpoint,
2575            ::aws_smithy_types::endpoint::Endpoint::builder()
2576                .url("https://bucket.s3-fips.dualstack.us-east-1.amazonaws.com")
2577                .auth_scheme(
2578                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2579                        .put("disableDoubleEncoding", true)
2580                        .put("signingName", "s3".to_string())
2581                        .put("signingRegion", "us-east-1".to_string())
2582                )
2583                .build()
2584        );
2585    }
2586
2587    /// URI encoded bucket + use global endpoint
2588    #[test]
2589    fn test_101() {
2590        let params = crate::config::endpoint::Params::builder()
2591            .region("us-east-1".to_string())
2592            .bucket("bucket!".to_string())
2593            .use_fips(true)
2594            .use_dual_stack(false)
2595            .use_global_endpoint(true)
2596            .endpoint("https://foo.com".to_string())
2597            .build()
2598            .expect("invalid params");
2599        let resolver = crate::config::endpoint::DefaultResolver::new();
2600        let endpoint = resolver.resolve_endpoint(&params);
2601        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [URI encoded bucket + use global endpoint]");
2602        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2603    }
2604
2605    /// FIPS + path based endpoint
2606    #[test]
2607    fn test_102() {
2608        let params = crate::config::endpoint::Params::builder()
2609            .region("us-east-1".to_string())
2610            .bucket("bucket!".to_string())
2611            .use_fips(true)
2612            .use_dual_stack(false)
2613            .accelerate(false)
2614            .use_global_endpoint(true)
2615            .build()
2616            .expect("invalid params");
2617        let resolver = crate::config::endpoint::DefaultResolver::new();
2618        let endpoint = resolver.resolve_endpoint(&params);
2619        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
2620        assert_eq!(
2621            endpoint,
2622            ::aws_smithy_types::endpoint::Endpoint::builder()
2623                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
2624                .auth_scheme(
2625                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2626                        .put("disableDoubleEncoding", true)
2627                        .put("signingName", "s3".to_string())
2628                        .put("signingRegion", "us-east-1".to_string())
2629                )
2630                .build()
2631        );
2632    }
2633
2634    /// accelerate + dualstack + global endpoint
2635    #[test]
2636    fn test_103() {
2637        let params = crate::config::endpoint::Params::builder()
2638            .region("us-east-1".to_string())
2639            .bucket("bucket".to_string())
2640            .use_fips(false)
2641            .use_dual_stack(true)
2642            .accelerate(true)
2643            .use_global_endpoint(true)
2644            .build()
2645            .expect("invalid params");
2646        let resolver = crate::config::endpoint::DefaultResolver::new();
2647        let endpoint = resolver.resolve_endpoint(&params);
2648        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.dualstack.amazonaws.com");
2649        assert_eq!(
2650            endpoint,
2651            ::aws_smithy_types::endpoint::Endpoint::builder()
2652                .url("https://bucket.s3-accelerate.dualstack.amazonaws.com")
2653                .auth_scheme(
2654                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2655                        .put("disableDoubleEncoding", true)
2656                        .put("signingName", "s3".to_string())
2657                        .put("signingRegion", "us-east-1".to_string())
2658                )
2659                .build()
2660        );
2661    }
2662
2663    /// dualstack + global endpoint + non URI safe bucket
2664    #[test]
2665    fn test_104() {
2666        let params = crate::config::endpoint::Params::builder()
2667            .region("us-east-1".to_string())
2668            .bucket("bucket!".to_string())
2669            .accelerate(false)
2670            .use_dual_stack(true)
2671            .use_fips(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.dualstack.us-east-1.amazonaws.com/bucket%21");
2678        assert_eq!(
2679            endpoint,
2680            ::aws_smithy_types::endpoint::Endpoint::builder()
2681                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket%21")
2682                .auth_scheme(
2683                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2684                        .put("disableDoubleEncoding", true)
2685                        .put("signingName", "s3".to_string())
2686                        .put("signingRegion", "us-east-1".to_string())
2687                )
2688                .build()
2689        );
2690    }
2691
2692    /// FIPS + uri encoded bucket
2693    #[test]
2694    fn test_105() {
2695        let params = crate::config::endpoint::Params::builder()
2696            .region("us-east-1".to_string())
2697            .bucket("bucket!".to_string())
2698            .force_path_style(true)
2699            .accelerate(false)
2700            .use_dual_stack(false)
2701            .use_fips(true)
2702            .use_global_endpoint(true)
2703            .build()
2704            .expect("invalid params");
2705        let resolver = crate::config::endpoint::DefaultResolver::new();
2706        let endpoint = resolver.resolve_endpoint(&params);
2707        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
2708        assert_eq!(
2709            endpoint,
2710            ::aws_smithy_types::endpoint::Endpoint::builder()
2711                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
2712                .auth_scheme(
2713                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2714                        .put("disableDoubleEncoding", true)
2715                        .put("signingName", "s3".to_string())
2716                        .put("signingRegion", "us-east-1".to_string())
2717                )
2718                .build()
2719        );
2720    }
2721
2722    /// endpoint override + non-uri safe endpoint + force path style
2723    #[test]
2724    fn test_106() {
2725        let params = crate::config::endpoint::Params::builder()
2726            .region("us-east-1".to_string())
2727            .bucket("bucket!".to_string())
2728            .force_path_style(true)
2729            .accelerate(false)
2730            .use_dual_stack(false)
2731            .use_fips(true)
2732            .endpoint("http://foo.com".to_string())
2733            .use_global_endpoint(true)
2734            .build()
2735            .expect("invalid params");
2736        let resolver = crate::config::endpoint::DefaultResolver::new();
2737        let endpoint = resolver.resolve_endpoint(&params);
2738        let error = endpoint.expect_err(
2739            "expected error: A custom endpoint cannot be combined with FIPS [endpoint override + non-uri safe endpoint + force path style]",
2740        );
2741        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2742    }
2743
2744    /// FIPS + Dualstack + global endpoint + non-dns bucket
2745    #[test]
2746    fn test_107() {
2747        let params = crate::config::endpoint::Params::builder()
2748            .region("us-east-1".to_string())
2749            .bucket("bucket!".to_string())
2750            .accelerate(false)
2751            .use_dual_stack(true)
2752            .use_fips(true)
2753            .use_global_endpoint(true)
2754            .build()
2755            .expect("invalid params");
2756        let resolver = crate::config::endpoint::DefaultResolver::new();
2757        let endpoint = resolver.resolve_endpoint(&params);
2758        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
2759        assert_eq!(
2760            endpoint,
2761            ::aws_smithy_types::endpoint::Endpoint::builder()
2762                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
2763                .auth_scheme(
2764                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2765                        .put("disableDoubleEncoding", true)
2766                        .put("signingName", "s3".to_string())
2767                        .put("signingRegion", "us-east-1".to_string())
2768                )
2769                .build()
2770        );
2771    }
2772
2773    /// endpoint override + FIPS + dualstack
2774    #[test]
2775    fn test_108() {
2776        let params = crate::config::endpoint::Params::builder()
2777            .region("us-east-1".to_string())
2778            .use_dual_stack(true)
2779            .use_fips(true)
2780            .use_global_endpoint(true)
2781            .endpoint("http://foo.com".to_string())
2782            .build()
2783            .expect("invalid params");
2784        let resolver = crate::config::endpoint::DefaultResolver::new();
2785        let endpoint = resolver.resolve_endpoint(&params);
2786        let error = endpoint
2787            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [endpoint override + FIPS + dualstack]");
2788        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
2789    }
2790
2791    /// non-bucket endpoint override + dualstack + global endpoint
2792    #[test]
2793    fn test_109() {
2794        let params = crate::config::endpoint::Params::builder()
2795            .region("us-east-1".to_string())
2796            .use_fips(false)
2797            .use_dual_stack(true)
2798            .use_global_endpoint(true)
2799            .endpoint("http://foo.com".to_string())
2800            .build()
2801            .expect("invalid params");
2802        let resolver = crate::config::endpoint::DefaultResolver::new();
2803        let endpoint = resolver.resolve_endpoint(&params);
2804        let error = endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [non-bucket endpoint override + dualstack + global endpoint]");
2805        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
2806    }
2807
2808    /// Endpoint override + UseGlobalEndpoint + us-east-1
2809    #[test]
2810    fn test_110() {
2811        let params = crate::config::endpoint::Params::builder()
2812            .region("us-east-1".to_string())
2813            .use_fips(true)
2814            .use_dual_stack(false)
2815            .use_global_endpoint(true)
2816            .endpoint("http://foo.com".to_string())
2817            .build()
2818            .expect("invalid params");
2819        let resolver = crate::config::endpoint::DefaultResolver::new();
2820        let endpoint = resolver.resolve_endpoint(&params);
2821        let error =
2822            endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [Endpoint override + UseGlobalEndpoint + us-east-1]");
2823        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2824    }
2825
2826    /// non-FIPS partition with FIPS set + custom endpoint
2827    #[test]
2828    fn test_111() {
2829        let params = crate::config::endpoint::Params::builder()
2830            .region("cn-north-1".to_string())
2831            .use_fips(true)
2832            .use_dual_stack(false)
2833            .use_global_endpoint(true)
2834            .build()
2835            .expect("invalid params");
2836        let resolver = crate::config::endpoint::DefaultResolver::new();
2837        let endpoint = resolver.resolve_endpoint(&params);
2838        let error = endpoint.expect_err("expected error: Partition does not support FIPS [non-FIPS partition with FIPS set + custom endpoint]");
2839        assert_eq!(format!("{}", error), "Partition does not support FIPS")
2840    }
2841
2842    /// aws-global signs as us-east-1
2843    #[test]
2844    fn test_112() {
2845        let params = crate::config::endpoint::Params::builder()
2846            .region("aws-global".to_string())
2847            .bucket("bucket!".to_string())
2848            .use_fips(true)
2849            .accelerate(false)
2850            .use_dual_stack(true)
2851            .build()
2852            .expect("invalid params");
2853        let resolver = crate::config::endpoint::DefaultResolver::new();
2854        let endpoint = resolver.resolve_endpoint(&params);
2855        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
2856        assert_eq!(
2857            endpoint,
2858            ::aws_smithy_types::endpoint::Endpoint::builder()
2859                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
2860                .auth_scheme(
2861                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2862                        .put("disableDoubleEncoding", true)
2863                        .put("signingName", "s3".to_string())
2864                        .put("signingRegion", "us-east-1".to_string())
2865                )
2866                .build()
2867        );
2868    }
2869
2870    /// aws-global signs as us-east-1
2871    #[test]
2872    fn test_113() {
2873        let params = crate::config::endpoint::Params::builder()
2874            .region("aws-global".to_string())
2875            .bucket("bucket".to_string())
2876            .use_dual_stack(false)
2877            .use_fips(false)
2878            .accelerate(false)
2879            .endpoint("https://foo.com".to_string())
2880            .build()
2881            .expect("invalid params");
2882        let resolver = crate::config::endpoint::DefaultResolver::new();
2883        let endpoint = resolver.resolve_endpoint(&params);
2884        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.foo.com");
2885        assert_eq!(
2886            endpoint,
2887            ::aws_smithy_types::endpoint::Endpoint::builder()
2888                .url("https://bucket.foo.com")
2889                .auth_scheme(
2890                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2891                        .put("disableDoubleEncoding", true)
2892                        .put("signingName", "s3".to_string())
2893                        .put("signingRegion", "us-east-1".to_string())
2894                )
2895                .build()
2896        );
2897    }
2898
2899    /// aws-global + dualstack + path-only bucket
2900    #[test]
2901    fn test_114() {
2902        let params = crate::config::endpoint::Params::builder()
2903            .region("aws-global".to_string())
2904            .bucket("bucket!".to_string())
2905            .use_dual_stack(true)
2906            .use_fips(false)
2907            .accelerate(false)
2908            .build()
2909            .expect("invalid params");
2910        let resolver = crate::config::endpoint::DefaultResolver::new();
2911        let endpoint = resolver.resolve_endpoint(&params);
2912        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-east-1.amazonaws.com/bucket%21");
2913        assert_eq!(
2914            endpoint,
2915            ::aws_smithy_types::endpoint::Endpoint::builder()
2916                .url("https://s3.dualstack.us-east-1.amazonaws.com/bucket%21")
2917                .auth_scheme(
2918                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2919                        .put("disableDoubleEncoding", true)
2920                        .put("signingName", "s3".to_string())
2921                        .put("signingRegion", "us-east-1".to_string())
2922                )
2923                .build()
2924        );
2925    }
2926
2927    /// aws-global + path-only bucket
2928    #[test]
2929    fn test_115() {
2930        let params = crate::config::endpoint::Params::builder()
2931            .region("aws-global".to_string())
2932            .bucket("bucket!".to_string())
2933            .build()
2934            .expect("invalid params");
2935        let resolver = crate::config::endpoint::DefaultResolver::new();
2936        let endpoint = resolver.resolve_endpoint(&params);
2937        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.amazonaws.com/bucket%21");
2938        assert_eq!(
2939            endpoint,
2940            ::aws_smithy_types::endpoint::Endpoint::builder()
2941                .url("https://s3.amazonaws.com/bucket%21")
2942                .auth_scheme(
2943                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2944                        .put("disableDoubleEncoding", true)
2945                        .put("signingName", "s3".to_string())
2946                        .put("signingRegion", "us-east-1".to_string())
2947                )
2948                .build()
2949        );
2950    }
2951
2952    /// aws-global + fips + custom endpoint
2953    #[test]
2954    fn test_116() {
2955        let params = crate::config::endpoint::Params::builder()
2956            .region("aws-global".to_string())
2957            .bucket("bucket!".to_string())
2958            .use_dual_stack(false)
2959            .use_fips(true)
2960            .accelerate(false)
2961            .endpoint("http://foo.com".to_string())
2962            .build()
2963            .expect("invalid params");
2964        let resolver = crate::config::endpoint::DefaultResolver::new();
2965        let endpoint = resolver.resolve_endpoint(&params);
2966        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [aws-global + fips + custom endpoint]");
2967        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
2968    }
2969
2970    /// aws-global, endpoint override & path only-bucket
2971    #[test]
2972    fn test_117() {
2973        let params = crate::config::endpoint::Params::builder()
2974            .region("aws-global".to_string())
2975            .bucket("bucket!".to_string())
2976            .use_dual_stack(false)
2977            .use_fips(false)
2978            .accelerate(false)
2979            .endpoint("http://foo.com".to_string())
2980            .build()
2981            .expect("invalid params");
2982        let resolver = crate::config::endpoint::DefaultResolver::new();
2983        let endpoint = resolver.resolve_endpoint(&params);
2984        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
2985        assert_eq!(
2986            endpoint,
2987            ::aws_smithy_types::endpoint::Endpoint::builder()
2988                .url("http://foo.com/bucket%21")
2989                .auth_scheme(
2990                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
2991                        .put("disableDoubleEncoding", true)
2992                        .put("signingName", "s3".to_string())
2993                        .put("signingRegion", "us-east-1".to_string())
2994                )
2995                .build()
2996        );
2997    }
2998
2999    /// aws-global + dualstack + custom endpoint
3000    #[test]
3001    fn test_118() {
3002        let params = crate::config::endpoint::Params::builder()
3003            .region("aws-global".to_string())
3004            .use_dual_stack(true)
3005            .use_fips(false)
3006            .accelerate(false)
3007            .endpoint("http://foo.com".to_string())
3008            .build()
3009            .expect("invalid params");
3010        let resolver = crate::config::endpoint::DefaultResolver::new();
3011        let endpoint = resolver.resolve_endpoint(&params);
3012        let error = endpoint
3013            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [aws-global + dualstack + custom endpoint]");
3014        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3015    }
3016
3017    /// accelerate, dualstack + aws-global
3018    #[test]
3019    fn test_119() {
3020        let params = crate::config::endpoint::Params::builder()
3021            .region("aws-global".to_string())
3022            .bucket("bucket".to_string())
3023            .use_dual_stack(true)
3024            .use_fips(false)
3025            .accelerate(true)
3026            .build()
3027            .expect("invalid params");
3028        let resolver = crate::config::endpoint::DefaultResolver::new();
3029        let endpoint = resolver.resolve_endpoint(&params);
3030        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.dualstack.us-east-1.amazonaws.com");
3031        assert_eq!(
3032            endpoint,
3033            ::aws_smithy_types::endpoint::Endpoint::builder()
3034                .url("https://bucket.s3-accelerate.dualstack.us-east-1.amazonaws.com")
3035                .auth_scheme(
3036                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3037                        .put("disableDoubleEncoding", true)
3038                        .put("signingName", "s3".to_string())
3039                        .put("signingRegion", "us-east-1".to_string())
3040                )
3041                .build()
3042        );
3043    }
3044
3045    /// FIPS + aws-global + path only bucket. This is not supported by S3 but we allow garbage in garbage out
3046    #[test]
3047    fn test_120() {
3048        let params = crate::config::endpoint::Params::builder()
3049            .region("aws-global".to_string())
3050            .bucket("bucket!".to_string())
3051            .force_path_style(true)
3052            .use_dual_stack(true)
3053            .use_fips(true)
3054            .accelerate(false)
3055            .build()
3056            .expect("invalid params");
3057        let resolver = crate::config::endpoint::DefaultResolver::new();
3058        let endpoint = resolver.resolve_endpoint(&params);
3059        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21");
3060        assert_eq!(
3061            endpoint,
3062            ::aws_smithy_types::endpoint::Endpoint::builder()
3063                .url("https://s3-fips.dualstack.us-east-1.amazonaws.com/bucket%21")
3064                .auth_scheme(
3065                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3066                        .put("disableDoubleEncoding", true)
3067                        .put("signingName", "s3".to_string())
3068                        .put("signingRegion", "us-east-1".to_string())
3069                )
3070                .build()
3071        );
3072    }
3073
3074    /// aws-global + FIPS + endpoint override.
3075    #[test]
3076    fn test_121() {
3077        let params = crate::config::endpoint::Params::builder()
3078            .region("aws-global".to_string())
3079            .use_fips(true)
3080            .endpoint("http://foo.com".to_string())
3081            .build()
3082            .expect("invalid params");
3083        let resolver = crate::config::endpoint::DefaultResolver::new();
3084        let endpoint = resolver.resolve_endpoint(&params);
3085        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [aws-global + FIPS + endpoint override.]");
3086        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3087    }
3088
3089    /// force path style, FIPS, aws-global & endpoint override
3090    #[test]
3091    fn test_122() {
3092        let params = crate::config::endpoint::Params::builder()
3093            .region("aws-global".to_string())
3094            .bucket("bucket!".to_string())
3095            .force_path_style(true)
3096            .use_fips(true)
3097            .endpoint("http://foo.com".to_string())
3098            .build()
3099            .expect("invalid params");
3100        let resolver = crate::config::endpoint::DefaultResolver::new();
3101        let endpoint = resolver.resolve_endpoint(&params);
3102        let error = endpoint
3103            .expect_err("expected error: A custom endpoint cannot be combined with FIPS [force path style, FIPS, aws-global & endpoint override]");
3104        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
3105    }
3106
3107    /// ip address causes path style to be forced
3108    #[test]
3109    fn test_123() {
3110        let params = crate::config::endpoint::Params::builder()
3111            .region("aws-global".to_string())
3112            .bucket("bucket".to_string())
3113            .endpoint("http://192.168.1.1".to_string())
3114            .build()
3115            .expect("invalid params");
3116        let resolver = crate::config::endpoint::DefaultResolver::new();
3117        let endpoint = resolver.resolve_endpoint(&params);
3118        let endpoint = endpoint.expect("Expected valid endpoint: http://192.168.1.1/bucket");
3119        assert_eq!(
3120            endpoint,
3121            ::aws_smithy_types::endpoint::Endpoint::builder()
3122                .url("http://192.168.1.1/bucket")
3123                .auth_scheme(
3124                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3125                        .put("disableDoubleEncoding", true)
3126                        .put("signingName", "s3".to_string())
3127                        .put("signingRegion", "us-east-1".to_string())
3128                )
3129                .build()
3130        );
3131    }
3132
3133    /// endpoint override with aws-global region
3134    #[test]
3135    fn test_124() {
3136        let params = crate::config::endpoint::Params::builder()
3137            .region("aws-global".to_string())
3138            .use_fips(true)
3139            .use_dual_stack(true)
3140            .endpoint("http://foo.com".to_string())
3141            .build()
3142            .expect("invalid params");
3143        let resolver = crate::config::endpoint::DefaultResolver::new();
3144        let endpoint = resolver.resolve_endpoint(&params);
3145        let error = endpoint
3146            .expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [endpoint override with aws-global region]");
3147        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
3148    }
3149
3150    /// FIPS + path-only (TODO: consider making this an error)
3151    #[test]
3152    fn test_125() {
3153        let params = crate::config::endpoint::Params::builder()
3154            .region("aws-global".to_string())
3155            .bucket("bucket!".to_string())
3156            .use_fips(true)
3157            .build()
3158            .expect("invalid params");
3159        let resolver = crate::config::endpoint::DefaultResolver::new();
3160        let endpoint = resolver.resolve_endpoint(&params);
3161        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-east-1.amazonaws.com/bucket%21");
3162        assert_eq!(
3163            endpoint,
3164            ::aws_smithy_types::endpoint::Endpoint::builder()
3165                .url("https://s3-fips.us-east-1.amazonaws.com/bucket%21")
3166                .auth_scheme(
3167                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3168                        .put("disableDoubleEncoding", true)
3169                        .put("signingName", "s3".to_string())
3170                        .put("signingRegion", "us-east-1".to_string())
3171                )
3172                .build()
3173        );
3174    }
3175
3176    /// empty arn type
3177    #[test]
3178    fn test_126() {
3179        let params = crate::config::endpoint::Params::builder()
3180            .region("us-east-2".to_string())
3181            .bucket("arn:aws:not-s3:us-west-2:123456789012::myendpoint".to_string())
3182            .build()
3183            .expect("invalid params");
3184        let resolver = crate::config::endpoint::DefaultResolver::new();
3185        let endpoint = resolver.resolve_endpoint(&params);
3186        let error = endpoint.expect_err("expected error: Invalid ARN: No ARN type specified [empty arn type]");
3187        assert_eq!(format!("{}", error), "Invalid ARN: No ARN type specified")
3188    }
3189
3190    /// path style can't be used with accelerate
3191    #[test]
3192    fn test_127() {
3193        let params = crate::config::endpoint::Params::builder()
3194            .region("us-east-2".to_string())
3195            .bucket("bucket!".to_string())
3196            .accelerate(true)
3197            .build()
3198            .expect("invalid params");
3199        let resolver = crate::config::endpoint::DefaultResolver::new();
3200        let endpoint = resolver.resolve_endpoint(&params);
3201        let error =
3202            endpoint.expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style can't be used with accelerate]");
3203        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
3204    }
3205
3206    /// invalid region
3207    #[test]
3208    fn test_128() {
3209        let params = crate::config::endpoint::Params::builder()
3210            .region("us-east-2!".to_string())
3211            .bucket("bucket.subdomain".to_string())
3212            .endpoint("http://foo.com".to_string())
3213            .build()
3214            .expect("invalid params");
3215        let resolver = crate::config::endpoint::DefaultResolver::new();
3216        let endpoint = resolver.resolve_endpoint(&params);
3217        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [invalid region]");
3218        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
3219    }
3220
3221    /// invalid region
3222    #[test]
3223    fn test_129() {
3224        let params = crate::config::endpoint::Params::builder()
3225            .region("us-east-2!".to_string())
3226            .bucket("bucket".to_string())
3227            .endpoint("http://foo.com".to_string())
3228            .build()
3229            .expect("invalid params");
3230        let resolver = crate::config::endpoint::DefaultResolver::new();
3231        let endpoint = resolver.resolve_endpoint(&params);
3232        let error = endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [invalid region]");
3233        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
3234    }
3235
3236    /// empty arn type
3237    #[test]
3238    fn test_130() {
3239        let params = crate::config::endpoint::Params::builder()
3240            .region("us-east-2".to_string())
3241            .bucket("arn:aws:s3::123456789012:accesspoint:my_endpoint".to_string())
3242            .build()
3243            .expect("invalid params");
3244        let resolver = crate::config::endpoint::DefaultResolver::new();
3245        let endpoint = resolver.resolve_endpoint(&params);
3246        let error = endpoint.expect_err("expected error: Invalid Access Point Name [empty arn type]");
3247        assert_eq!(format!("{}", error), "Invalid Access Point Name")
3248    }
3249
3250    /// empty arn type
3251    #[test]
3252    fn test_131() {
3253        let params = crate::config::endpoint::Params::builder()
3254            .region("us-east-2".to_string())
3255            .bucket("arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint".to_string())
3256            .use_arn_region(true)
3257            .build()
3258            .expect("invalid params");
3259        let resolver = crate::config::endpoint::DefaultResolver::new();
3260        let endpoint = resolver.resolve_endpoint(&params);
3261        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]");
3262        assert_eq!(
3263            format!("{}", error),
3264            "Client was configured for partition `aws` but ARN (`arn:aws:s3:cn-north-1:123456789012:accesspoint:my-endpoint`) has `aws-cn`"
3265        )
3266    }
3267
3268    /// invalid arn region
3269    #[test]
3270    fn test_132() {
3271        let params = crate::config::endpoint::Params::builder()
3272            .region("us-east-2".to_string())
3273            .bucket("arn:aws:s3-object-lambda:us-east_2:123456789012:accesspoint:my-endpoint".to_string())
3274            .use_arn_region(true)
3275            .build()
3276            .expect("invalid params");
3277        let resolver = crate::config::endpoint::DefaultResolver::new();
3278        let endpoint = resolver.resolve_endpoint(&params);
3279        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-east_2` (invalid DNS name) [invalid arn region]");
3280        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-east_2` (invalid DNS name)")
3281    }
3282
3283    /// invalid ARN outpost
3284    #[test]
3285    fn test_133() {
3286        let params = crate::config::endpoint::Params::builder()
3287            .region("us-east-2".to_string())
3288            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op_01234567890123456/accesspoint/reports".to_string())
3289            .use_arn_region(true)
3290            .build()
3291            .expect("invalid params");
3292        let resolver = crate::config::endpoint::DefaultResolver::new();
3293        let endpoint = resolver.resolve_endpoint(&params);
3294        let error = endpoint.expect_err(
3295            "expected error: Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `op_01234567890123456` [invalid ARN outpost]",
3296        );
3297        assert_eq!(
3298            format!("{}", error),
3299            "Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `op_01234567890123456`"
3300        )
3301    }
3302
3303    /// invalid ARN
3304    #[test]
3305    fn test_134() {
3306        let params = crate::config::endpoint::Params::builder()
3307            .region("us-east-2".to_string())
3308            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/reports".to_string())
3309            .build()
3310            .expect("invalid params");
3311        let resolver = crate::config::endpoint::DefaultResolver::new();
3312        let endpoint = resolver.resolve_endpoint(&params);
3313        let error = endpoint.expect_err("expected error: Invalid ARN: expected an access point name [invalid ARN]");
3314        assert_eq!(format!("{}", error), "Invalid ARN: expected an access point name")
3315    }
3316
3317    /// invalid ARN
3318    #[test]
3319    fn test_135() {
3320        let params = crate::config::endpoint::Params::builder()
3321            .region("us-east-2".to_string())
3322            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456".to_string())
3323            .build()
3324            .expect("invalid params");
3325        let resolver = crate::config::endpoint::DefaultResolver::new();
3326        let endpoint = resolver.resolve_endpoint(&params);
3327        let error = endpoint.expect_err("expected error: Invalid ARN: Expected a 4-component resource [invalid ARN]");
3328        assert_eq!(format!("{}", error), "Invalid ARN: Expected a 4-component resource")
3329    }
3330
3331    /// invalid outpost type
3332    #[test]
3333    fn test_136() {
3334        let params = crate::config::endpoint::Params::builder()
3335            .region("us-east-2".to_string())
3336            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3337            .build()
3338            .expect("invalid params");
3339        let resolver = crate::config::endpoint::DefaultResolver::new();
3340        let endpoint = resolver.resolve_endpoint(&params);
3341        let error = endpoint.expect_err("expected error: Expected an outpost type `accesspoint`, found not-accesspoint [invalid outpost type]");
3342        assert_eq!(format!("{}", error), "Expected an outpost type `accesspoint`, found not-accesspoint")
3343    }
3344
3345    /// invalid outpost type
3346    #[test]
3347    fn test_137() {
3348        let params = crate::config::endpoint::Params::builder()
3349            .region("us-east-2".to_string())
3350            .bucket("arn:aws:s3-outposts:us-east_1:123456789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3351            .build()
3352            .expect("invalid params");
3353        let resolver = crate::config::endpoint::DefaultResolver::new();
3354        let endpoint = resolver.resolve_endpoint(&params);
3355        let error = endpoint.expect_err("expected error: Invalid region in ARN: `us-east_1` (invalid DNS name) [invalid outpost type]");
3356        assert_eq!(format!("{}", error), "Invalid region in ARN: `us-east_1` (invalid DNS name)")
3357    }
3358
3359    /// invalid outpost type
3360    #[test]
3361    fn test_138() {
3362        let params = crate::config::endpoint::Params::builder()
3363            .region("us-east-2".to_string())
3364            .bucket("arn:aws:s3-outposts:us-east-1:12345_789012:outpost/op-01234567890123456/not-accesspoint/reports".to_string())
3365            .build()
3366            .expect("invalid params");
3367        let resolver = crate::config::endpoint::DefaultResolver::new();
3368        let endpoint = resolver.resolve_endpoint(&params);
3369        let error = endpoint.expect_err(
3370            "expected error: Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `12345_789012` [invalid outpost type]",
3371        );
3372        assert_eq!(
3373            format!("{}", error),
3374            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `12345_789012`"
3375        )
3376    }
3377
3378    /// invalid outpost type
3379    #[test]
3380    fn test_139() {
3381        let params = crate::config::endpoint::Params::builder()
3382            .region("us-east-2".to_string())
3383            .bucket("arn:aws:s3-outposts:us-east-1:12345789012:outpost".to_string())
3384            .build()
3385            .expect("invalid params");
3386        let resolver = crate::config::endpoint::DefaultResolver::new();
3387        let endpoint = resolver.resolve_endpoint(&params);
3388        let error = endpoint.expect_err("expected error: Invalid ARN: The Outpost Id was not set [invalid outpost type]");
3389        assert_eq!(format!("{}", error), "Invalid ARN: The Outpost Id was not set")
3390    }
3391
3392    /// use global endpoint virtual addressing
3393    #[test]
3394    fn test_140() {
3395        let params = crate::config::endpoint::Params::builder()
3396            .region("us-east-2".to_string())
3397            .bucket("bucket".to_string())
3398            .endpoint("http://example.com".to_string())
3399            .use_global_endpoint(true)
3400            .build()
3401            .expect("invalid params");
3402        let resolver = crate::config::endpoint::DefaultResolver::new();
3403        let endpoint = resolver.resolve_endpoint(&params);
3404        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket.example.com");
3405        assert_eq!(
3406            endpoint,
3407            ::aws_smithy_types::endpoint::Endpoint::builder()
3408                .url("http://bucket.example.com")
3409                .auth_scheme(
3410                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3411                        .put("disableDoubleEncoding", true)
3412                        .put("signingName", "s3".to_string())
3413                        .put("signingRegion", "us-east-2".to_string())
3414                )
3415                .build()
3416        );
3417    }
3418
3419    /// global endpoint + ip address
3420    #[test]
3421    fn test_141() {
3422        let params = crate::config::endpoint::Params::builder()
3423            .region("us-east-2".to_string())
3424            .bucket("bucket".to_string())
3425            .endpoint("http://192.168.0.1".to_string())
3426            .use_global_endpoint(true)
3427            .build()
3428            .expect("invalid params");
3429        let resolver = crate::config::endpoint::DefaultResolver::new();
3430        let endpoint = resolver.resolve_endpoint(&params);
3431        let endpoint = endpoint.expect("Expected valid endpoint: http://192.168.0.1/bucket");
3432        assert_eq!(
3433            endpoint,
3434            ::aws_smithy_types::endpoint::Endpoint::builder()
3435                .url("http://192.168.0.1/bucket")
3436                .auth_scheme(
3437                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3438                        .put("disableDoubleEncoding", true)
3439                        .put("signingName", "s3".to_string())
3440                        .put("signingRegion", "us-east-2".to_string())
3441                )
3442                .build()
3443        );
3444    }
3445
3446    /// invalid outpost type
3447    #[test]
3448    fn test_142() {
3449        let params = crate::config::endpoint::Params::builder()
3450            .region("us-east-2".to_string())
3451            .bucket("bucket!".to_string())
3452            .use_global_endpoint(true)
3453            .build()
3454            .expect("invalid params");
3455        let resolver = crate::config::endpoint::DefaultResolver::new();
3456        let endpoint = resolver.resolve_endpoint(&params);
3457        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-east-2.amazonaws.com/bucket%21");
3458        assert_eq!(
3459            endpoint,
3460            ::aws_smithy_types::endpoint::Endpoint::builder()
3461                .url("https://s3.us-east-2.amazonaws.com/bucket%21")
3462                .auth_scheme(
3463                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3464                        .put("disableDoubleEncoding", true)
3465                        .put("signingName", "s3".to_string())
3466                        .put("signingRegion", "us-east-2".to_string())
3467                )
3468                .build()
3469        );
3470    }
3471
3472    /// invalid outpost type
3473    #[test]
3474    fn test_143() {
3475        let params = crate::config::endpoint::Params::builder()
3476            .region("us-east-2".to_string())
3477            .bucket("bucket".to_string())
3478            .accelerate(true)
3479            .use_global_endpoint(true)
3480            .build()
3481            .expect("invalid params");
3482        let resolver = crate::config::endpoint::DefaultResolver::new();
3483        let endpoint = resolver.resolve_endpoint(&params);
3484        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket.s3-accelerate.amazonaws.com");
3485        assert_eq!(
3486            endpoint,
3487            ::aws_smithy_types::endpoint::Endpoint::builder()
3488                .url("https://bucket.s3-accelerate.amazonaws.com")
3489                .auth_scheme(
3490                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3491                        .put("disableDoubleEncoding", true)
3492                        .put("signingName", "s3".to_string())
3493                        .put("signingRegion", "us-east-2".to_string())
3494                )
3495                .build()
3496        );
3497    }
3498
3499    /// use global endpoint + custom endpoint
3500    #[test]
3501    fn test_144() {
3502        let params = crate::config::endpoint::Params::builder()
3503            .region("us-east-2".to_string())
3504            .bucket("bucket!".to_string())
3505            .use_global_endpoint(true)
3506            .endpoint("http://foo.com".to_string())
3507            .build()
3508            .expect("invalid params");
3509        let resolver = crate::config::endpoint::DefaultResolver::new();
3510        let endpoint = resolver.resolve_endpoint(&params);
3511        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
3512        assert_eq!(
3513            endpoint,
3514            ::aws_smithy_types::endpoint::Endpoint::builder()
3515                .url("http://foo.com/bucket%21")
3516                .auth_scheme(
3517                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3518                        .put("disableDoubleEncoding", true)
3519                        .put("signingName", "s3".to_string())
3520                        .put("signingRegion", "us-east-2".to_string())
3521                )
3522                .build()
3523        );
3524    }
3525
3526    /// use global endpoint, not us-east-1, force path style
3527    #[test]
3528    fn test_145() {
3529        let params = crate::config::endpoint::Params::builder()
3530            .region("us-east-2".to_string())
3531            .bucket("bucket!".to_string())
3532            .use_global_endpoint(true)
3533            .force_path_style(true)
3534            .endpoint("http://foo.com".to_string())
3535            .build()
3536            .expect("invalid params");
3537        let resolver = crate::config::endpoint::DefaultResolver::new();
3538        let endpoint = resolver.resolve_endpoint(&params);
3539        let endpoint = endpoint.expect("Expected valid endpoint: http://foo.com/bucket%21");
3540        assert_eq!(
3541            endpoint,
3542            ::aws_smithy_types::endpoint::Endpoint::builder()
3543                .url("http://foo.com/bucket%21")
3544                .auth_scheme(
3545                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3546                        .put("disableDoubleEncoding", true)
3547                        .put("signingName", "s3".to_string())
3548                        .put("signingRegion", "us-east-2".to_string())
3549                )
3550                .build()
3551        );
3552    }
3553
3554    /// vanilla virtual addressing@us-west-2
3555    #[test]
3556    fn test_146() {
3557        let params = crate::config::endpoint::Params::builder()
3558            .accelerate(false)
3559            .bucket("bucket-name".to_string())
3560            .force_path_style(false)
3561            .region("us-west-2".to_string())
3562            .use_dual_stack(false)
3563            .use_fips(false)
3564            .build()
3565            .expect("invalid params");
3566        let resolver = crate::config::endpoint::DefaultResolver::new();
3567        let endpoint = resolver.resolve_endpoint(&params);
3568        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.us-west-2.amazonaws.com");
3569        assert_eq!(
3570            endpoint,
3571            ::aws_smithy_types::endpoint::Endpoint::builder()
3572                .url("https://bucket-name.s3.us-west-2.amazonaws.com")
3573                .auth_scheme(
3574                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3575                        .put("disableDoubleEncoding", true)
3576                        .put("signingName", "s3".to_string())
3577                        .put("signingRegion", "us-west-2".to_string())
3578                )
3579                .build()
3580        );
3581    }
3582
3583    /// virtual addressing + dualstack@us-west-2
3584    #[test]
3585    fn test_147() {
3586        let params = crate::config::endpoint::Params::builder()
3587            .accelerate(false)
3588            .bucket("bucket-name".to_string())
3589            .force_path_style(false)
3590            .region("us-west-2".to_string())
3591            .use_dual_stack(true)
3592            .use_fips(false)
3593            .build()
3594            .expect("invalid params");
3595        let resolver = crate::config::endpoint::DefaultResolver::new();
3596        let endpoint = resolver.resolve_endpoint(&params);
3597        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.us-west-2.amazonaws.com");
3598        assert_eq!(
3599            endpoint,
3600            ::aws_smithy_types::endpoint::Endpoint::builder()
3601                .url("https://bucket-name.s3.dualstack.us-west-2.amazonaws.com")
3602                .auth_scheme(
3603                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3604                        .put("disableDoubleEncoding", true)
3605                        .put("signingName", "s3".to_string())
3606                        .put("signingRegion", "us-west-2".to_string())
3607                )
3608                .build()
3609        );
3610    }
3611
3612    /// accelerate + dualstack@us-west-2
3613    #[test]
3614    fn test_148() {
3615        let params = crate::config::endpoint::Params::builder()
3616            .accelerate(true)
3617            .bucket("bucket-name".to_string())
3618            .force_path_style(false)
3619            .region("us-west-2".to_string())
3620            .use_dual_stack(true)
3621            .use_fips(false)
3622            .build()
3623            .expect("invalid params");
3624        let resolver = crate::config::endpoint::DefaultResolver::new();
3625        let endpoint = resolver.resolve_endpoint(&params);
3626        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.dualstack.amazonaws.com");
3627        assert_eq!(
3628            endpoint,
3629            ::aws_smithy_types::endpoint::Endpoint::builder()
3630                .url("https://bucket-name.s3-accelerate.dualstack.amazonaws.com")
3631                .auth_scheme(
3632                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3633                        .put("disableDoubleEncoding", true)
3634                        .put("signingName", "s3".to_string())
3635                        .put("signingRegion", "us-west-2".to_string())
3636                )
3637                .build()
3638        );
3639    }
3640
3641    /// accelerate (dualstack=false)@us-west-2
3642    #[test]
3643    fn test_149() {
3644        let params = crate::config::endpoint::Params::builder()
3645            .accelerate(true)
3646            .bucket("bucket-name".to_string())
3647            .force_path_style(false)
3648            .region("us-west-2".to_string())
3649            .use_dual_stack(false)
3650            .use_fips(false)
3651            .build()
3652            .expect("invalid params");
3653        let resolver = crate::config::endpoint::DefaultResolver::new();
3654        let endpoint = resolver.resolve_endpoint(&params);
3655        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
3656        assert_eq!(
3657            endpoint,
3658            ::aws_smithy_types::endpoint::Endpoint::builder()
3659                .url("https://bucket-name.s3-accelerate.amazonaws.com")
3660                .auth_scheme(
3661                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3662                        .put("disableDoubleEncoding", true)
3663                        .put("signingName", "s3".to_string())
3664                        .put("signingRegion", "us-west-2".to_string())
3665                )
3666                .build()
3667        );
3668    }
3669
3670    /// virtual addressing + fips@us-west-2
3671    #[test]
3672    fn test_150() {
3673        let params = crate::config::endpoint::Params::builder()
3674            .accelerate(false)
3675            .bucket("bucket-name".to_string())
3676            .force_path_style(false)
3677            .region("us-west-2".to_string())
3678            .use_dual_stack(false)
3679            .use_fips(true)
3680            .build()
3681            .expect("invalid params");
3682        let resolver = crate::config::endpoint::DefaultResolver::new();
3683        let endpoint = resolver.resolve_endpoint(&params);
3684        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.us-west-2.amazonaws.com");
3685        assert_eq!(
3686            endpoint,
3687            ::aws_smithy_types::endpoint::Endpoint::builder()
3688                .url("https://bucket-name.s3-fips.us-west-2.amazonaws.com")
3689                .auth_scheme(
3690                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3691                        .put("disableDoubleEncoding", true)
3692                        .put("signingName", "s3".to_string())
3693                        .put("signingRegion", "us-west-2".to_string())
3694                )
3695                .build()
3696        );
3697    }
3698
3699    /// virtual addressing + dualstack + fips@us-west-2
3700    #[test]
3701    fn test_151() {
3702        let params = crate::config::endpoint::Params::builder()
3703            .accelerate(false)
3704            .bucket("bucket-name".to_string())
3705            .force_path_style(false)
3706            .region("us-west-2".to_string())
3707            .use_dual_stack(true)
3708            .use_fips(true)
3709            .build()
3710            .expect("invalid params");
3711        let resolver = crate::config::endpoint::DefaultResolver::new();
3712        let endpoint = resolver.resolve_endpoint(&params);
3713        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.us-west-2.amazonaws.com");
3714        assert_eq!(
3715            endpoint,
3716            ::aws_smithy_types::endpoint::Endpoint::builder()
3717                .url("https://bucket-name.s3-fips.dualstack.us-west-2.amazonaws.com")
3718                .auth_scheme(
3719                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3720                        .put("disableDoubleEncoding", true)
3721                        .put("signingName", "s3".to_string())
3722                        .put("signingRegion", "us-west-2".to_string())
3723                )
3724                .build()
3725        );
3726    }
3727
3728    /// accelerate + fips = error@us-west-2
3729    #[test]
3730    fn test_152() {
3731        let params = crate::config::endpoint::Params::builder()
3732            .accelerate(true)
3733            .bucket("bucket-name".to_string())
3734            .force_path_style(false)
3735            .region("us-west-2".to_string())
3736            .use_dual_stack(false)
3737            .use_fips(true)
3738            .build()
3739            .expect("invalid params");
3740        let resolver = crate::config::endpoint::DefaultResolver::new();
3741        let endpoint = resolver.resolve_endpoint(&params);
3742        let error = endpoint.expect_err("expected error: Accelerate cannot be used with FIPS [accelerate + fips = error@us-west-2]");
3743        assert_eq!(format!("{}", error), "Accelerate cannot be used with FIPS")
3744    }
3745
3746    /// vanilla virtual addressing@cn-north-1
3747    #[test]
3748    fn test_153() {
3749        let params = crate::config::endpoint::Params::builder()
3750            .accelerate(false)
3751            .bucket("bucket-name".to_string())
3752            .force_path_style(false)
3753            .region("cn-north-1".to_string())
3754            .use_dual_stack(false)
3755            .use_fips(false)
3756            .build()
3757            .expect("invalid params");
3758        let resolver = crate::config::endpoint::DefaultResolver::new();
3759        let endpoint = resolver.resolve_endpoint(&params);
3760        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.cn-north-1.amazonaws.com.cn");
3761        assert_eq!(
3762            endpoint,
3763            ::aws_smithy_types::endpoint::Endpoint::builder()
3764                .url("https://bucket-name.s3.cn-north-1.amazonaws.com.cn")
3765                .auth_scheme(
3766                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3767                        .put("disableDoubleEncoding", true)
3768                        .put("signingName", "s3".to_string())
3769                        .put("signingRegion", "cn-north-1".to_string())
3770                )
3771                .build()
3772        );
3773    }
3774
3775    /// virtual addressing + dualstack@cn-north-1
3776    #[test]
3777    fn test_154() {
3778        let params = crate::config::endpoint::Params::builder()
3779            .accelerate(false)
3780            .bucket("bucket-name".to_string())
3781            .force_path_style(false)
3782            .region("cn-north-1".to_string())
3783            .use_dual_stack(true)
3784            .use_fips(false)
3785            .build()
3786            .expect("invalid params");
3787        let resolver = crate::config::endpoint::DefaultResolver::new();
3788        let endpoint = resolver.resolve_endpoint(&params);
3789        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.cn-north-1.amazonaws.com.cn");
3790        assert_eq!(
3791            endpoint,
3792            ::aws_smithy_types::endpoint::Endpoint::builder()
3793                .url("https://bucket-name.s3.dualstack.cn-north-1.amazonaws.com.cn")
3794                .auth_scheme(
3795                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3796                        .put("disableDoubleEncoding", true)
3797                        .put("signingName", "s3".to_string())
3798                        .put("signingRegion", "cn-north-1".to_string())
3799                )
3800                .build()
3801        );
3802    }
3803
3804    /// accelerate (dualstack=false)@cn-north-1
3805    #[test]
3806    fn test_155() {
3807        let params = crate::config::endpoint::Params::builder()
3808            .accelerate(true)
3809            .bucket("bucket-name".to_string())
3810            .force_path_style(false)
3811            .region("cn-north-1".to_string())
3812            .use_dual_stack(false)
3813            .use_fips(false)
3814            .build()
3815            .expect("invalid params");
3816        let resolver = crate::config::endpoint::DefaultResolver::new();
3817        let endpoint = resolver.resolve_endpoint(&params);
3818        let error = endpoint.expect_err("expected error: S3 Accelerate cannot be used in this region [accelerate (dualstack=false)@cn-north-1]");
3819        assert_eq!(format!("{}", error), "S3 Accelerate cannot be used in this region")
3820    }
3821
3822    /// virtual addressing + fips@cn-north-1
3823    #[test]
3824    fn test_156() {
3825        let params = crate::config::endpoint::Params::builder()
3826            .accelerate(false)
3827            .bucket("bucket-name".to_string())
3828            .force_path_style(false)
3829            .region("cn-north-1".to_string())
3830            .use_dual_stack(false)
3831            .use_fips(true)
3832            .build()
3833            .expect("invalid params");
3834        let resolver = crate::config::endpoint::DefaultResolver::new();
3835        let endpoint = resolver.resolve_endpoint(&params);
3836        let error = endpoint.expect_err("expected error: Partition does not support FIPS [virtual addressing + fips@cn-north-1]");
3837        assert_eq!(format!("{}", error), "Partition does not support FIPS")
3838    }
3839
3840    /// vanilla virtual addressing@af-south-1
3841    #[test]
3842    fn test_157() {
3843        let params = crate::config::endpoint::Params::builder()
3844            .accelerate(false)
3845            .bucket("bucket-name".to_string())
3846            .force_path_style(false)
3847            .region("af-south-1".to_string())
3848            .use_dual_stack(false)
3849            .use_fips(false)
3850            .build()
3851            .expect("invalid params");
3852        let resolver = crate::config::endpoint::DefaultResolver::new();
3853        let endpoint = resolver.resolve_endpoint(&params);
3854        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.af-south-1.amazonaws.com");
3855        assert_eq!(
3856            endpoint,
3857            ::aws_smithy_types::endpoint::Endpoint::builder()
3858                .url("https://bucket-name.s3.af-south-1.amazonaws.com")
3859                .auth_scheme(
3860                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3861                        .put("disableDoubleEncoding", true)
3862                        .put("signingName", "s3".to_string())
3863                        .put("signingRegion", "af-south-1".to_string())
3864                )
3865                .build()
3866        );
3867    }
3868
3869    /// virtual addressing + dualstack@af-south-1
3870    #[test]
3871    fn test_158() {
3872        let params = crate::config::endpoint::Params::builder()
3873            .accelerate(false)
3874            .bucket("bucket-name".to_string())
3875            .force_path_style(false)
3876            .region("af-south-1".to_string())
3877            .use_dual_stack(true)
3878            .use_fips(false)
3879            .build()
3880            .expect("invalid params");
3881        let resolver = crate::config::endpoint::DefaultResolver::new();
3882        let endpoint = resolver.resolve_endpoint(&params);
3883        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3.dualstack.af-south-1.amazonaws.com");
3884        assert_eq!(
3885            endpoint,
3886            ::aws_smithy_types::endpoint::Endpoint::builder()
3887                .url("https://bucket-name.s3.dualstack.af-south-1.amazonaws.com")
3888                .auth_scheme(
3889                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3890                        .put("disableDoubleEncoding", true)
3891                        .put("signingName", "s3".to_string())
3892                        .put("signingRegion", "af-south-1".to_string())
3893                )
3894                .build()
3895        );
3896    }
3897
3898    /// accelerate + dualstack@af-south-1
3899    #[test]
3900    fn test_159() {
3901        let params = crate::config::endpoint::Params::builder()
3902            .accelerate(true)
3903            .bucket("bucket-name".to_string())
3904            .force_path_style(false)
3905            .region("af-south-1".to_string())
3906            .use_dual_stack(true)
3907            .use_fips(false)
3908            .build()
3909            .expect("invalid params");
3910        let resolver = crate::config::endpoint::DefaultResolver::new();
3911        let endpoint = resolver.resolve_endpoint(&params);
3912        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.dualstack.amazonaws.com");
3913        assert_eq!(
3914            endpoint,
3915            ::aws_smithy_types::endpoint::Endpoint::builder()
3916                .url("https://bucket-name.s3-accelerate.dualstack.amazonaws.com")
3917                .auth_scheme(
3918                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3919                        .put("disableDoubleEncoding", true)
3920                        .put("signingName", "s3".to_string())
3921                        .put("signingRegion", "af-south-1".to_string())
3922                )
3923                .build()
3924        );
3925    }
3926
3927    /// accelerate (dualstack=false)@af-south-1
3928    #[test]
3929    fn test_160() {
3930        let params = crate::config::endpoint::Params::builder()
3931            .accelerate(true)
3932            .bucket("bucket-name".to_string())
3933            .force_path_style(false)
3934            .region("af-south-1".to_string())
3935            .use_dual_stack(false)
3936            .use_fips(false)
3937            .build()
3938            .expect("invalid params");
3939        let resolver = crate::config::endpoint::DefaultResolver::new();
3940        let endpoint = resolver.resolve_endpoint(&params);
3941        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-accelerate.amazonaws.com");
3942        assert_eq!(
3943            endpoint,
3944            ::aws_smithy_types::endpoint::Endpoint::builder()
3945                .url("https://bucket-name.s3-accelerate.amazonaws.com")
3946                .auth_scheme(
3947                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3948                        .put("disableDoubleEncoding", true)
3949                        .put("signingName", "s3".to_string())
3950                        .put("signingRegion", "af-south-1".to_string())
3951                )
3952                .build()
3953        );
3954    }
3955
3956    /// virtual addressing + fips@af-south-1
3957    #[test]
3958    fn test_161() {
3959        let params = crate::config::endpoint::Params::builder()
3960            .accelerate(false)
3961            .bucket("bucket-name".to_string())
3962            .force_path_style(false)
3963            .region("af-south-1".to_string())
3964            .use_dual_stack(false)
3965            .use_fips(true)
3966            .build()
3967            .expect("invalid params");
3968        let resolver = crate::config::endpoint::DefaultResolver::new();
3969        let endpoint = resolver.resolve_endpoint(&params);
3970        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.af-south-1.amazonaws.com");
3971        assert_eq!(
3972            endpoint,
3973            ::aws_smithy_types::endpoint::Endpoint::builder()
3974                .url("https://bucket-name.s3-fips.af-south-1.amazonaws.com")
3975                .auth_scheme(
3976                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
3977                        .put("disableDoubleEncoding", true)
3978                        .put("signingName", "s3".to_string())
3979                        .put("signingRegion", "af-south-1".to_string())
3980                )
3981                .build()
3982        );
3983    }
3984
3985    /// virtual addressing + dualstack + fips@af-south-1
3986    #[test]
3987    fn test_162() {
3988        let params = crate::config::endpoint::Params::builder()
3989            .accelerate(false)
3990            .bucket("bucket-name".to_string())
3991            .force_path_style(false)
3992            .region("af-south-1".to_string())
3993            .use_dual_stack(true)
3994            .use_fips(true)
3995            .build()
3996            .expect("invalid params");
3997        let resolver = crate::config::endpoint::DefaultResolver::new();
3998        let endpoint = resolver.resolve_endpoint(&params);
3999        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.s3-fips.dualstack.af-south-1.amazonaws.com");
4000        assert_eq!(
4001            endpoint,
4002            ::aws_smithy_types::endpoint::Endpoint::builder()
4003                .url("https://bucket-name.s3-fips.dualstack.af-south-1.amazonaws.com")
4004                .auth_scheme(
4005                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4006                        .put("disableDoubleEncoding", true)
4007                        .put("signingName", "s3".to_string())
4008                        .put("signingRegion", "af-south-1".to_string())
4009                )
4010                .build()
4011        );
4012    }
4013
4014    /// accelerate + fips = error@af-south-1
4015    #[test]
4016    fn test_163() {
4017        let params = crate::config::endpoint::Params::builder()
4018            .accelerate(true)
4019            .bucket("bucket-name".to_string())
4020            .force_path_style(false)
4021            .region("af-south-1".to_string())
4022            .use_dual_stack(false)
4023            .use_fips(true)
4024            .build()
4025            .expect("invalid params");
4026        let resolver = crate::config::endpoint::DefaultResolver::new();
4027        let endpoint = resolver.resolve_endpoint(&params);
4028        let error = endpoint.expect_err("expected error: Accelerate cannot be used with FIPS [accelerate + fips = error@af-south-1]");
4029        assert_eq!(format!("{}", error), "Accelerate cannot be used with FIPS")
4030    }
4031
4032    /// vanilla path style@us-west-2
4033    #[test]
4034    fn test_164() {
4035        let params = crate::config::endpoint::Params::builder()
4036            .accelerate(false)
4037            .bucket("bucket-name".to_string())
4038            .force_path_style(true)
4039            .region("us-west-2".to_string())
4040            .use_dual_stack(false)
4041            .use_fips(false)
4042            .build()
4043            .expect("invalid params");
4044        let resolver = crate::config::endpoint::DefaultResolver::new();
4045        let endpoint = resolver.resolve_endpoint(&params);
4046        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/bucket-name");
4047        assert_eq!(
4048            endpoint,
4049            ::aws_smithy_types::endpoint::Endpoint::builder()
4050                .url("https://s3.us-west-2.amazonaws.com/bucket-name")
4051                .auth_scheme(
4052                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4053                        .put("disableDoubleEncoding", true)
4054                        .put("signingName", "s3".to_string())
4055                        .put("signingRegion", "us-west-2".to_string())
4056                )
4057                .build()
4058        );
4059    }
4060
4061    /// fips@us-gov-west-2, bucket is not S3-dns-compatible (subdomains)
4062    #[test]
4063    fn test_165() {
4064        let params = crate::config::endpoint::Params::builder()
4065            .accelerate(false)
4066            .bucket("bucket.with.dots".to_string())
4067            .region("us-gov-west-1".to_string())
4068            .use_dual_stack(false)
4069            .use_fips(true)
4070            .build()
4071            .expect("invalid params");
4072        let resolver = crate::config::endpoint::DefaultResolver::new();
4073        let endpoint = resolver.resolve_endpoint(&params);
4074        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.us-gov-west-1.amazonaws.com/bucket.with.dots");
4075        assert_eq!(
4076            endpoint,
4077            ::aws_smithy_types::endpoint::Endpoint::builder()
4078                .url("https://s3-fips.us-gov-west-1.amazonaws.com/bucket.with.dots")
4079                .auth_scheme(
4080                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4081                        .put("disableDoubleEncoding", true)
4082                        .put("signingName", "s3".to_string())
4083                        .put("signingRegion", "us-gov-west-1".to_string())
4084                )
4085                .build()
4086        );
4087    }
4088
4089    /// path style + accelerate = error@us-west-2
4090    #[test]
4091    fn test_166() {
4092        let params = crate::config::endpoint::Params::builder()
4093            .accelerate(true)
4094            .bucket("bucket-name".to_string())
4095            .force_path_style(true)
4096            .region("us-west-2".to_string())
4097            .use_dual_stack(false)
4098            .use_fips(false)
4099            .build()
4100            .expect("invalid params");
4101        let resolver = crate::config::endpoint::DefaultResolver::new();
4102        let endpoint = resolver.resolve_endpoint(&params);
4103        let error = endpoint
4104            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@us-west-2]");
4105        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
4106    }
4107
4108    /// path style + dualstack@us-west-2
4109    #[test]
4110    fn test_167() {
4111        let params = crate::config::endpoint::Params::builder()
4112            .accelerate(false)
4113            .bucket("bucket-name".to_string())
4114            .force_path_style(true)
4115            .region("us-west-2".to_string())
4116            .use_dual_stack(true)
4117            .use_fips(false)
4118            .build()
4119            .expect("invalid params");
4120        let resolver = crate::config::endpoint::DefaultResolver::new();
4121        let endpoint = resolver.resolve_endpoint(&params);
4122        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.us-west-2.amazonaws.com/bucket-name");
4123        assert_eq!(
4124            endpoint,
4125            ::aws_smithy_types::endpoint::Endpoint::builder()
4126                .url("https://s3.dualstack.us-west-2.amazonaws.com/bucket-name")
4127                .auth_scheme(
4128                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4129                        .put("disableDoubleEncoding", true)
4130                        .put("signingName", "s3".to_string())
4131                        .put("signingRegion", "us-west-2".to_string())
4132                )
4133                .build()
4134        );
4135    }
4136
4137    /// path style + arn is error@us-west-2
4138    #[test]
4139    fn test_168() {
4140        let params = crate::config::endpoint::Params::builder()
4141            .accelerate(false)
4142            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
4143            .force_path_style(true)
4144            .region("us-west-2".to_string())
4145            .use_dual_stack(false)
4146            .use_fips(false)
4147            .build()
4148            .expect("invalid params");
4149        let resolver = crate::config::endpoint::DefaultResolver::new();
4150        let endpoint = resolver.resolve_endpoint(&params);
4151        let error =
4152            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@us-west-2]");
4153        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
4154    }
4155
4156    /// path style + invalid DNS name@us-west-2
4157    #[test]
4158    fn test_169() {
4159        let params = crate::config::endpoint::Params::builder()
4160            .accelerate(false)
4161            .bucket("99a_b".to_string())
4162            .force_path_style(true)
4163            .region("us-west-2".to_string())
4164            .use_dual_stack(false)
4165            .use_fips(false)
4166            .build()
4167            .expect("invalid params");
4168        let resolver = crate::config::endpoint::DefaultResolver::new();
4169        let endpoint = resolver.resolve_endpoint(&params);
4170        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/99a_b");
4171        assert_eq!(
4172            endpoint,
4173            ::aws_smithy_types::endpoint::Endpoint::builder()
4174                .url("https://s3.us-west-2.amazonaws.com/99a_b")
4175                .auth_scheme(
4176                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4177                        .put("disableDoubleEncoding", true)
4178                        .put("signingName", "s3".to_string())
4179                        .put("signingRegion", "us-west-2".to_string())
4180                )
4181                .build()
4182        );
4183    }
4184
4185    /// no path style + invalid DNS name@us-west-2
4186    #[test]
4187    fn test_170() {
4188        let params = crate::config::endpoint::Params::builder()
4189            .accelerate(false)
4190            .bucket("99a_b".to_string())
4191            .region("us-west-2".to_string())
4192            .use_dual_stack(false)
4193            .use_fips(false)
4194            .build()
4195            .expect("invalid params");
4196        let resolver = crate::config::endpoint::DefaultResolver::new();
4197        let endpoint = resolver.resolve_endpoint(&params);
4198        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.us-west-2.amazonaws.com/99a_b");
4199        assert_eq!(
4200            endpoint,
4201            ::aws_smithy_types::endpoint::Endpoint::builder()
4202                .url("https://s3.us-west-2.amazonaws.com/99a_b")
4203                .auth_scheme(
4204                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4205                        .put("disableDoubleEncoding", true)
4206                        .put("signingName", "s3".to_string())
4207                        .put("signingRegion", "us-west-2".to_string())
4208                )
4209                .build()
4210        );
4211    }
4212
4213    /// vanilla path style@cn-north-1
4214    #[test]
4215    fn test_171() {
4216        let params = crate::config::endpoint::Params::builder()
4217            .accelerate(false)
4218            .bucket("bucket-name".to_string())
4219            .force_path_style(true)
4220            .region("cn-north-1".to_string())
4221            .use_dual_stack(false)
4222            .use_fips(false)
4223            .build()
4224            .expect("invalid params");
4225        let resolver = crate::config::endpoint::DefaultResolver::new();
4226        let endpoint = resolver.resolve_endpoint(&params);
4227        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/bucket-name");
4228        assert_eq!(
4229            endpoint,
4230            ::aws_smithy_types::endpoint::Endpoint::builder()
4231                .url("https://s3.cn-north-1.amazonaws.com.cn/bucket-name")
4232                .auth_scheme(
4233                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4234                        .put("disableDoubleEncoding", true)
4235                        .put("signingName", "s3".to_string())
4236                        .put("signingRegion", "cn-north-1".to_string())
4237                )
4238                .build()
4239        );
4240    }
4241
4242    /// path style + fips@cn-north-1
4243    #[test]
4244    fn test_172() {
4245        let params = crate::config::endpoint::Params::builder()
4246            .accelerate(false)
4247            .bucket("bucket-name".to_string())
4248            .force_path_style(true)
4249            .region("cn-north-1".to_string())
4250            .use_dual_stack(false)
4251            .use_fips(true)
4252            .build()
4253            .expect("invalid params");
4254        let resolver = crate::config::endpoint::DefaultResolver::new();
4255        let endpoint = resolver.resolve_endpoint(&params);
4256        let error = endpoint.expect_err("expected error: Partition does not support FIPS [path style + fips@cn-north-1]");
4257        assert_eq!(format!("{}", error), "Partition does not support FIPS")
4258    }
4259
4260    /// path style + accelerate = error@cn-north-1
4261    #[test]
4262    fn test_173() {
4263        let params = crate::config::endpoint::Params::builder()
4264            .accelerate(true)
4265            .bucket("bucket-name".to_string())
4266            .force_path_style(true)
4267            .region("cn-north-1".to_string())
4268            .use_dual_stack(false)
4269            .use_fips(false)
4270            .build()
4271            .expect("invalid params");
4272        let resolver = crate::config::endpoint::DefaultResolver::new();
4273        let endpoint = resolver.resolve_endpoint(&params);
4274        let error = endpoint
4275            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@cn-north-1]");
4276        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
4277    }
4278
4279    /// path style + dualstack@cn-north-1
4280    #[test]
4281    fn test_174() {
4282        let params = crate::config::endpoint::Params::builder()
4283            .accelerate(false)
4284            .bucket("bucket-name".to_string())
4285            .force_path_style(true)
4286            .region("cn-north-1".to_string())
4287            .use_dual_stack(true)
4288            .use_fips(false)
4289            .build()
4290            .expect("invalid params");
4291        let resolver = crate::config::endpoint::DefaultResolver::new();
4292        let endpoint = resolver.resolve_endpoint(&params);
4293        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.cn-north-1.amazonaws.com.cn/bucket-name");
4294        assert_eq!(
4295            endpoint,
4296            ::aws_smithy_types::endpoint::Endpoint::builder()
4297                .url("https://s3.dualstack.cn-north-1.amazonaws.com.cn/bucket-name")
4298                .auth_scheme(
4299                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4300                        .put("disableDoubleEncoding", true)
4301                        .put("signingName", "s3".to_string())
4302                        .put("signingRegion", "cn-north-1".to_string())
4303                )
4304                .build()
4305        );
4306    }
4307
4308    /// path style + arn is error@cn-north-1
4309    #[test]
4310    fn test_175() {
4311        let params = crate::config::endpoint::Params::builder()
4312            .accelerate(false)
4313            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
4314            .force_path_style(true)
4315            .region("cn-north-1".to_string())
4316            .use_dual_stack(false)
4317            .use_fips(false)
4318            .build()
4319            .expect("invalid params");
4320        let resolver = crate::config::endpoint::DefaultResolver::new();
4321        let endpoint = resolver.resolve_endpoint(&params);
4322        let error =
4323            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@cn-north-1]");
4324        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
4325    }
4326
4327    /// path style + invalid DNS name@cn-north-1
4328    #[test]
4329    fn test_176() {
4330        let params = crate::config::endpoint::Params::builder()
4331            .accelerate(false)
4332            .bucket("99a_b".to_string())
4333            .force_path_style(true)
4334            .region("cn-north-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://s3.cn-north-1.amazonaws.com.cn/99a_b");
4342        assert_eq!(
4343            endpoint,
4344            ::aws_smithy_types::endpoint::Endpoint::builder()
4345                .url("https://s3.cn-north-1.amazonaws.com.cn/99a_b")
4346                .auth_scheme(
4347                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4348                        .put("disableDoubleEncoding", true)
4349                        .put("signingName", "s3".to_string())
4350                        .put("signingRegion", "cn-north-1".to_string())
4351                )
4352                .build()
4353        );
4354    }
4355
4356    /// no path style + invalid DNS name@cn-north-1
4357    #[test]
4358    fn test_177() {
4359        let params = crate::config::endpoint::Params::builder()
4360            .accelerate(false)
4361            .bucket("99a_b".to_string())
4362            .region("cn-north-1".to_string())
4363            .use_dual_stack(false)
4364            .use_fips(false)
4365            .build()
4366            .expect("invalid params");
4367        let resolver = crate::config::endpoint::DefaultResolver::new();
4368        let endpoint = resolver.resolve_endpoint(&params);
4369        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.cn-north-1.amazonaws.com.cn/99a_b");
4370        assert_eq!(
4371            endpoint,
4372            ::aws_smithy_types::endpoint::Endpoint::builder()
4373                .url("https://s3.cn-north-1.amazonaws.com.cn/99a_b")
4374                .auth_scheme(
4375                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4376                        .put("disableDoubleEncoding", true)
4377                        .put("signingName", "s3".to_string())
4378                        .put("signingRegion", "cn-north-1".to_string())
4379                )
4380                .build()
4381        );
4382    }
4383
4384    /// vanilla path style@af-south-1
4385    #[test]
4386    fn test_178() {
4387        let params = crate::config::endpoint::Params::builder()
4388            .accelerate(false)
4389            .bucket("bucket-name".to_string())
4390            .force_path_style(true)
4391            .region("af-south-1".to_string())
4392            .use_dual_stack(false)
4393            .use_fips(false)
4394            .build()
4395            .expect("invalid params");
4396        let resolver = crate::config::endpoint::DefaultResolver::new();
4397        let endpoint = resolver.resolve_endpoint(&params);
4398        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/bucket-name");
4399        assert_eq!(
4400            endpoint,
4401            ::aws_smithy_types::endpoint::Endpoint::builder()
4402                .url("https://s3.af-south-1.amazonaws.com/bucket-name")
4403                .auth_scheme(
4404                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4405                        .put("disableDoubleEncoding", true)
4406                        .put("signingName", "s3".to_string())
4407                        .put("signingRegion", "af-south-1".to_string())
4408                )
4409                .build()
4410        );
4411    }
4412
4413    /// path style + fips@af-south-1
4414    #[test]
4415    fn test_179() {
4416        let params = crate::config::endpoint::Params::builder()
4417            .accelerate(false)
4418            .bucket("bucket-name".to_string())
4419            .force_path_style(true)
4420            .region("af-south-1".to_string())
4421            .use_dual_stack(false)
4422            .use_fips(true)
4423            .build()
4424            .expect("invalid params");
4425        let resolver = crate::config::endpoint::DefaultResolver::new();
4426        let endpoint = resolver.resolve_endpoint(&params);
4427        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-fips.af-south-1.amazonaws.com/bucket-name");
4428        assert_eq!(
4429            endpoint,
4430            ::aws_smithy_types::endpoint::Endpoint::builder()
4431                .url("https://s3-fips.af-south-1.amazonaws.com/bucket-name")
4432                .auth_scheme(
4433                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4434                        .put("disableDoubleEncoding", true)
4435                        .put("signingName", "s3".to_string())
4436                        .put("signingRegion", "af-south-1".to_string())
4437                )
4438                .build()
4439        );
4440    }
4441
4442    /// path style + accelerate = error@af-south-1
4443    #[test]
4444    fn test_180() {
4445        let params = crate::config::endpoint::Params::builder()
4446            .accelerate(true)
4447            .bucket("bucket-name".to_string())
4448            .force_path_style(true)
4449            .region("af-south-1".to_string())
4450            .use_dual_stack(false)
4451            .use_fips(false)
4452            .build()
4453            .expect("invalid params");
4454        let resolver = crate::config::endpoint::DefaultResolver::new();
4455        let endpoint = resolver.resolve_endpoint(&params);
4456        let error = endpoint
4457            .expect_err("expected error: Path-style addressing cannot be used with S3 Accelerate [path style + accelerate = error@af-south-1]");
4458        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with S3 Accelerate")
4459    }
4460
4461    /// path style + dualstack@af-south-1
4462    #[test]
4463    fn test_181() {
4464        let params = crate::config::endpoint::Params::builder()
4465            .accelerate(false)
4466            .bucket("bucket-name".to_string())
4467            .force_path_style(true)
4468            .region("af-south-1".to_string())
4469            .use_dual_stack(true)
4470            .use_fips(false)
4471            .build()
4472            .expect("invalid params");
4473        let resolver = crate::config::endpoint::DefaultResolver::new();
4474        let endpoint = resolver.resolve_endpoint(&params);
4475        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.dualstack.af-south-1.amazonaws.com/bucket-name");
4476        assert_eq!(
4477            endpoint,
4478            ::aws_smithy_types::endpoint::Endpoint::builder()
4479                .url("https://s3.dualstack.af-south-1.amazonaws.com/bucket-name")
4480                .auth_scheme(
4481                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4482                        .put("disableDoubleEncoding", true)
4483                        .put("signingName", "s3".to_string())
4484                        .put("signingRegion", "af-south-1".to_string())
4485                )
4486                .build()
4487        );
4488    }
4489
4490    /// path style + arn is error@af-south-1
4491    #[test]
4492    fn test_182() {
4493        let params = crate::config::endpoint::Params::builder()
4494            .accelerate(false)
4495            .bucket("arn:PARTITION:s3-outposts:REGION:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_string())
4496            .force_path_style(true)
4497            .region("af-south-1".to_string())
4498            .use_dual_stack(false)
4499            .use_fips(false)
4500            .build()
4501            .expect("invalid params");
4502        let resolver = crate::config::endpoint::DefaultResolver::new();
4503        let endpoint = resolver.resolve_endpoint(&params);
4504        let error =
4505            endpoint.expect_err("expected error: Path-style addressing cannot be used with ARN buckets [path style + arn is error@af-south-1]");
4506        assert_eq!(format!("{}", error), "Path-style addressing cannot be used with ARN buckets")
4507    }
4508
4509    /// path style + invalid DNS name@af-south-1
4510    #[test]
4511    fn test_183() {
4512        let params = crate::config::endpoint::Params::builder()
4513            .accelerate(false)
4514            .bucket("99a_b".to_string())
4515            .force_path_style(true)
4516            .region("af-south-1".to_string())
4517            .use_dual_stack(false)
4518            .use_fips(false)
4519            .build()
4520            .expect("invalid params");
4521        let resolver = crate::config::endpoint::DefaultResolver::new();
4522        let endpoint = resolver.resolve_endpoint(&params);
4523        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/99a_b");
4524        assert_eq!(
4525            endpoint,
4526            ::aws_smithy_types::endpoint::Endpoint::builder()
4527                .url("https://s3.af-south-1.amazonaws.com/99a_b")
4528                .auth_scheme(
4529                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4530                        .put("disableDoubleEncoding", true)
4531                        .put("signingName", "s3".to_string())
4532                        .put("signingRegion", "af-south-1".to_string())
4533                )
4534                .build()
4535        );
4536    }
4537
4538    /// no path style + invalid DNS name@af-south-1
4539    #[test]
4540    fn test_184() {
4541        let params = crate::config::endpoint::Params::builder()
4542            .accelerate(false)
4543            .bucket("99a_b".to_string())
4544            .region("af-south-1".to_string())
4545            .use_dual_stack(false)
4546            .use_fips(false)
4547            .build()
4548            .expect("invalid params");
4549        let resolver = crate::config::endpoint::DefaultResolver::new();
4550        let endpoint = resolver.resolve_endpoint(&params);
4551        let endpoint = endpoint.expect("Expected valid endpoint: https://s3.af-south-1.amazonaws.com/99a_b");
4552        assert_eq!(
4553            endpoint,
4554            ::aws_smithy_types::endpoint::Endpoint::builder()
4555                .url("https://s3.af-south-1.amazonaws.com/99a_b")
4556                .auth_scheme(
4557                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4558                        .put("disableDoubleEncoding", true)
4559                        .put("signingName", "s3".to_string())
4560                        .put("signingRegion", "af-south-1".to_string())
4561                )
4562                .build()
4563        );
4564    }
4565
4566    /// virtual addressing + private link@us-west-2
4567    #[test]
4568    fn test_185() {
4569        let params = crate::config::endpoint::Params::builder()
4570            .accelerate(false)
4571            .bucket("bucket-name".to_string())
4572            .force_path_style(false)
4573            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
4574            .region("us-west-2".to_string())
4575            .use_dual_stack(false)
4576            .use_fips(false)
4577            .build()
4578            .expect("invalid params");
4579        let resolver = crate::config::endpoint::DefaultResolver::new();
4580        let endpoint = resolver.resolve_endpoint(&params);
4581        let endpoint = endpoint.expect("Expected valid endpoint: http://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
4582        assert_eq!(
4583            endpoint,
4584            ::aws_smithy_types::endpoint::Endpoint::builder()
4585                .url("http://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
4586                .auth_scheme(
4587                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4588                        .put("disableDoubleEncoding", true)
4589                        .put("signingName", "s3".to_string())
4590                        .put("signingRegion", "us-west-2".to_string())
4591                )
4592                .build()
4593        );
4594    }
4595
4596    /// path style + private link@us-west-2
4597    #[test]
4598    fn test_186() {
4599        let params = crate::config::endpoint::Params::builder()
4600            .accelerate(false)
4601            .bucket("bucket-name".to_string())
4602            .force_path_style(true)
4603            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
4604            .region("us-west-2".to_string())
4605            .use_dual_stack(false)
4606            .use_fips(false)
4607            .build()
4608            .expect("invalid params");
4609        let resolver = crate::config::endpoint::DefaultResolver::new();
4610        let endpoint = resolver.resolve_endpoint(&params);
4611        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
4612        assert_eq!(
4613            endpoint,
4614            ::aws_smithy_types::endpoint::Endpoint::builder()
4615                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
4616                .auth_scheme(
4617                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4618                        .put("disableDoubleEncoding", true)
4619                        .put("signingName", "s3".to_string())
4620                        .put("signingRegion", "us-west-2".to_string())
4621                )
4622                .build()
4623        );
4624    }
4625
4626    /// SDK::Host + FIPS@us-west-2
4627    #[test]
4628    fn test_187() {
4629        let params = crate::config::endpoint::Params::builder()
4630            .accelerate(false)
4631            .bucket("bucket-name".to_string())
4632            .force_path_style(false)
4633            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
4634            .region("us-west-2".to_string())
4635            .use_dual_stack(false)
4636            .use_fips(true)
4637            .build()
4638            .expect("invalid params");
4639        let resolver = crate::config::endpoint::DefaultResolver::new();
4640        let endpoint = resolver.resolve_endpoint(&params);
4641        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [SDK::Host + FIPS@us-west-2]");
4642        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
4643    }
4644
4645    /// SDK::Host + DualStack@us-west-2
4646    #[test]
4647    fn test_188() {
4648        let params = crate::config::endpoint::Params::builder()
4649            .accelerate(false)
4650            .bucket("bucket-name".to_string())
4651            .force_path_style(false)
4652            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
4653            .region("us-west-2".to_string())
4654            .use_dual_stack(true)
4655            .use_fips(false)
4656            .build()
4657            .expect("invalid params");
4658        let resolver = crate::config::endpoint::DefaultResolver::new();
4659        let endpoint = resolver.resolve_endpoint(&params);
4660        let error =
4661            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@us-west-2]");
4662        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
4663    }
4664
4665    /// SDK::HOST + accelerate@us-west-2
4666    #[test]
4667    fn test_189() {
4668        let params = crate::config::endpoint::Params::builder()
4669            .accelerate(true)
4670            .bucket("bucket-name".to_string())
4671            .force_path_style(false)
4672            .endpoint("http://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
4673            .region("us-west-2".to_string())
4674            .use_dual_stack(false)
4675            .use_fips(false)
4676            .build()
4677            .expect("invalid params");
4678        let resolver = crate::config::endpoint::DefaultResolver::new();
4679        let endpoint = resolver.resolve_endpoint(&params);
4680        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@us-west-2]");
4681        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
4682    }
4683
4684    /// SDK::Host + access point ARN@us-west-2
4685    #[test]
4686    fn test_190() {
4687        let params = crate::config::endpoint::Params::builder()
4688            .accelerate(false)
4689            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
4690            .force_path_style(false)
4691            .endpoint("https://beta.example.com".to_string())
4692            .region("us-west-2".to_string())
4693            .use_dual_stack(false)
4694            .use_fips(false)
4695            .build()
4696            .expect("invalid params");
4697        let resolver = crate::config::endpoint::DefaultResolver::new();
4698        let endpoint = resolver.resolve_endpoint(&params);
4699        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
4700        assert_eq!(
4701            endpoint,
4702            ::aws_smithy_types::endpoint::Endpoint::builder()
4703                .url("https://myendpoint-123456789012.beta.example.com")
4704                .auth_scheme(
4705                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4706                        .put("disableDoubleEncoding", true)
4707                        .put("signingName", "s3".to_string())
4708                        .put("signingRegion", "us-west-2".to_string())
4709                )
4710                .build()
4711        );
4712    }
4713
4714    /// virtual addressing + private link@cn-north-1
4715    #[test]
4716    fn test_191() {
4717        let params = crate::config::endpoint::Params::builder()
4718            .accelerate(false)
4719            .bucket("bucket-name".to_string())
4720            .force_path_style(false)
4721            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
4722            .region("cn-north-1".to_string())
4723            .use_dual_stack(false)
4724            .use_fips(false)
4725            .build()
4726            .expect("invalid params");
4727        let resolver = crate::config::endpoint::DefaultResolver::new();
4728        let endpoint = resolver.resolve_endpoint(&params);
4729        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
4730        assert_eq!(
4731            endpoint,
4732            ::aws_smithy_types::endpoint::Endpoint::builder()
4733                .url("https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
4734                .auth_scheme(
4735                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4736                        .put("disableDoubleEncoding", true)
4737                        .put("signingName", "s3".to_string())
4738                        .put("signingRegion", "cn-north-1".to_string())
4739                )
4740                .build()
4741        );
4742    }
4743
4744    /// path style + private link@cn-north-1
4745    #[test]
4746    fn test_192() {
4747        let params = crate::config::endpoint::Params::builder()
4748            .accelerate(false)
4749            .bucket("bucket-name".to_string())
4750            .force_path_style(true)
4751            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
4752            .region("cn-north-1".to_string())
4753            .use_dual_stack(false)
4754            .use_fips(false)
4755            .build()
4756            .expect("invalid params");
4757        let resolver = crate::config::endpoint::DefaultResolver::new();
4758        let endpoint = resolver.resolve_endpoint(&params);
4759        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
4760        assert_eq!(
4761            endpoint,
4762            ::aws_smithy_types::endpoint::Endpoint::builder()
4763                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
4764                .auth_scheme(
4765                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4766                        .put("disableDoubleEncoding", true)
4767                        .put("signingName", "s3".to_string())
4768                        .put("signingRegion", "cn-north-1".to_string())
4769                )
4770                .build()
4771        );
4772    }
4773
4774    /// FIPS@cn-north-1
4775    #[test]
4776    fn test_193() {
4777        let params = crate::config::endpoint::Params::builder()
4778            .accelerate(false)
4779            .bucket("bucket-name".to_string())
4780            .force_path_style(false)
4781            .region("cn-north-1".to_string())
4782            .use_dual_stack(false)
4783            .use_fips(true)
4784            .build()
4785            .expect("invalid params");
4786        let resolver = crate::config::endpoint::DefaultResolver::new();
4787        let endpoint = resolver.resolve_endpoint(&params);
4788        let error = endpoint.expect_err("expected error: Partition does not support FIPS [FIPS@cn-north-1]");
4789        assert_eq!(format!("{}", error), "Partition does not support FIPS")
4790    }
4791
4792    /// SDK::Host + DualStack@cn-north-1
4793    #[test]
4794    fn test_194() {
4795        let params = crate::config::endpoint::Params::builder()
4796            .accelerate(false)
4797            .bucket("bucket-name".to_string())
4798            .force_path_style(false)
4799            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
4800            .region("cn-north-1".to_string())
4801            .use_dual_stack(true)
4802            .use_fips(false)
4803            .build()
4804            .expect("invalid params");
4805        let resolver = crate::config::endpoint::DefaultResolver::new();
4806        let endpoint = resolver.resolve_endpoint(&params);
4807        let error =
4808            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@cn-north-1]");
4809        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
4810    }
4811
4812    /// SDK::HOST + accelerate@cn-north-1
4813    #[test]
4814    fn test_195() {
4815        let params = crate::config::endpoint::Params::builder()
4816            .accelerate(true)
4817            .bucket("bucket-name".to_string())
4818            .force_path_style(false)
4819            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
4820            .region("cn-north-1".to_string())
4821            .use_dual_stack(false)
4822            .use_fips(false)
4823            .build()
4824            .expect("invalid params");
4825        let resolver = crate::config::endpoint::DefaultResolver::new();
4826        let endpoint = resolver.resolve_endpoint(&params);
4827        let error =
4828            endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@cn-north-1]");
4829        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
4830    }
4831
4832    /// SDK::Host + access point ARN@cn-north-1
4833    #[test]
4834    fn test_196() {
4835        let params = crate::config::endpoint::Params::builder()
4836            .accelerate(false)
4837            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
4838            .force_path_style(false)
4839            .endpoint("https://beta.example.com".to_string())
4840            .region("cn-north-1".to_string())
4841            .use_dual_stack(false)
4842            .use_fips(false)
4843            .build()
4844            .expect("invalid params");
4845        let resolver = crate::config::endpoint::DefaultResolver::new();
4846        let endpoint = resolver.resolve_endpoint(&params);
4847        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
4848        assert_eq!(
4849            endpoint,
4850            ::aws_smithy_types::endpoint::Endpoint::builder()
4851                .url("https://myendpoint-123456789012.beta.example.com")
4852                .auth_scheme(
4853                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4854                        .put("disableDoubleEncoding", true)
4855                        .put("signingName", "s3".to_string())
4856                        .put("signingRegion", "cn-north-1".to_string())
4857                )
4858                .build()
4859        );
4860    }
4861
4862    /// virtual addressing + private link@af-south-1
4863    #[test]
4864    fn test_197() {
4865        let params = crate::config::endpoint::Params::builder()
4866            .accelerate(false)
4867            .bucket("bucket-name".to_string())
4868            .force_path_style(false)
4869            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
4870            .region("af-south-1".to_string())
4871            .use_dual_stack(false)
4872            .use_fips(false)
4873            .build()
4874            .expect("invalid params");
4875        let resolver = crate::config::endpoint::DefaultResolver::new();
4876        let endpoint = resolver.resolve_endpoint(&params);
4877        let endpoint = endpoint.expect("Expected valid endpoint: https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
4878        assert_eq!(
4879            endpoint,
4880            ::aws_smithy_types::endpoint::Endpoint::builder()
4881                .url("https://bucket-name.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com")
4882                .auth_scheme(
4883                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4884                        .put("disableDoubleEncoding", true)
4885                        .put("signingName", "s3".to_string())
4886                        .put("signingRegion", "af-south-1".to_string())
4887                )
4888                .build()
4889        );
4890    }
4891
4892    /// path style + private link@af-south-1
4893    #[test]
4894    fn test_198() {
4895        let params = crate::config::endpoint::Params::builder()
4896            .accelerate(false)
4897            .bucket("bucket-name".to_string())
4898            .force_path_style(true)
4899            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
4900            .region("af-south-1".to_string())
4901            .use_dual_stack(false)
4902            .use_fips(false)
4903            .build()
4904            .expect("invalid params");
4905        let resolver = crate::config::endpoint::DefaultResolver::new();
4906        let endpoint = resolver.resolve_endpoint(&params);
4907        let endpoint = endpoint.expect("Expected valid endpoint: https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name");
4908        assert_eq!(
4909            endpoint,
4910            ::aws_smithy_types::endpoint::Endpoint::builder()
4911                .url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com/bucket-name")
4912                .auth_scheme(
4913                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
4914                        .put("disableDoubleEncoding", true)
4915                        .put("signingName", "s3".to_string())
4916                        .put("signingRegion", "af-south-1".to_string())
4917                )
4918                .build()
4919        );
4920    }
4921
4922    /// SDK::Host + FIPS@af-south-1
4923    #[test]
4924    fn test_199() {
4925        let params = crate::config::endpoint::Params::builder()
4926            .accelerate(false)
4927            .bucket("bucket-name".to_string())
4928            .force_path_style(false)
4929            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
4930            .region("af-south-1".to_string())
4931            .use_dual_stack(false)
4932            .use_fips(true)
4933            .build()
4934            .expect("invalid params");
4935        let resolver = crate::config::endpoint::DefaultResolver::new();
4936        let endpoint = resolver.resolve_endpoint(&params);
4937        let error = endpoint.expect_err("expected error: A custom endpoint cannot be combined with FIPS [SDK::Host + FIPS@af-south-1]");
4938        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with FIPS")
4939    }
4940
4941    /// SDK::Host + DualStack@af-south-1
4942    #[test]
4943    fn test_200() {
4944        let params = crate::config::endpoint::Params::builder()
4945            .accelerate(false)
4946            .bucket("bucket-name".to_string())
4947            .force_path_style(false)
4948            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
4949            .region("af-south-1".to_string())
4950            .use_dual_stack(true)
4951            .use_fips(false)
4952            .build()
4953            .expect("invalid params");
4954        let resolver = crate::config::endpoint::DefaultResolver::new();
4955        let endpoint = resolver.resolve_endpoint(&params);
4956        let error =
4957            endpoint.expect_err("expected error: Cannot set dual-stack in combination with a custom endpoint. [SDK::Host + DualStack@af-south-1]");
4958        assert_eq!(format!("{}", error), "Cannot set dual-stack in combination with a custom endpoint.")
4959    }
4960
4961    /// SDK::HOST + accelerate@af-south-1
4962    #[test]
4963    fn test_201() {
4964        let params = crate::config::endpoint::Params::builder()
4965            .accelerate(true)
4966            .bucket("bucket-name".to_string())
4967            .force_path_style(false)
4968            .endpoint("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com".to_string())
4969            .region("af-south-1".to_string())
4970            .use_dual_stack(false)
4971            .use_fips(false)
4972            .build()
4973            .expect("invalid params");
4974        let resolver = crate::config::endpoint::DefaultResolver::new();
4975        let endpoint = resolver.resolve_endpoint(&params);
4976        let error =
4977            endpoint.expect_err("expected error: A custom endpoint cannot be combined with S3 Accelerate [SDK::HOST + accelerate@af-south-1]");
4978        assert_eq!(format!("{}", error), "A custom endpoint cannot be combined with S3 Accelerate")
4979    }
4980
4981    /// SDK::Host + access point ARN@af-south-1
4982    #[test]
4983    fn test_202() {
4984        let params = crate::config::endpoint::Params::builder()
4985            .accelerate(false)
4986            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
4987            .force_path_style(false)
4988            .endpoint("https://beta.example.com".to_string())
4989            .region("af-south-1".to_string())
4990            .use_dual_stack(false)
4991            .use_fips(false)
4992            .build()
4993            .expect("invalid params");
4994        let resolver = crate::config::endpoint::DefaultResolver::new();
4995        let endpoint = resolver.resolve_endpoint(&params);
4996        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.beta.example.com");
4997        assert_eq!(
4998            endpoint,
4999            ::aws_smithy_types::endpoint::Endpoint::builder()
5000                .url("https://myendpoint-123456789012.beta.example.com")
5001                .auth_scheme(
5002                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5003                        .put("disableDoubleEncoding", true)
5004                        .put("signingName", "s3".to_string())
5005                        .put("signingRegion", "af-south-1".to_string())
5006                )
5007                .build()
5008        );
5009    }
5010
5011    /// vanilla access point arn@us-west-2
5012    #[test]
5013    fn test_203() {
5014        let params = crate::config::endpoint::Params::builder()
5015            .accelerate(false)
5016            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5017            .force_path_style(false)
5018            .region("us-west-2".to_string())
5019            .use_dual_stack(false)
5020            .use_fips(false)
5021            .build()
5022            .expect("invalid params");
5023        let resolver = crate::config::endpoint::DefaultResolver::new();
5024        let endpoint = resolver.resolve_endpoint(&params);
5025        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com");
5026        assert_eq!(
5027            endpoint,
5028            ::aws_smithy_types::endpoint::Endpoint::builder()
5029                .url("https://myendpoint-123456789012.s3-accesspoint.us-west-2.amazonaws.com")
5030                .auth_scheme(
5031                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5032                        .put("disableDoubleEncoding", true)
5033                        .put("signingName", "s3".to_string())
5034                        .put("signingRegion", "us-west-2".to_string())
5035                )
5036                .build()
5037        );
5038    }
5039
5040    /// access point arn + FIPS@us-west-2
5041    #[test]
5042    fn test_204() {
5043        let params = crate::config::endpoint::Params::builder()
5044            .accelerate(false)
5045            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5046            .force_path_style(false)
5047            .region("us-west-2".to_string())
5048            .use_dual_stack(false)
5049            .use_fips(true)
5050            .build()
5051            .expect("invalid params");
5052        let resolver = crate::config::endpoint::DefaultResolver::new();
5053        let endpoint = resolver.resolve_endpoint(&params);
5054        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.us-west-2.amazonaws.com");
5055        assert_eq!(
5056            endpoint,
5057            ::aws_smithy_types::endpoint::Endpoint::builder()
5058                .url("https://myendpoint-123456789012.s3-accesspoint-fips.us-west-2.amazonaws.com")
5059                .auth_scheme(
5060                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5061                        .put("disableDoubleEncoding", true)
5062                        .put("signingName", "s3".to_string())
5063                        .put("signingRegion", "us-west-2".to_string())
5064                )
5065                .build()
5066        );
5067    }
5068
5069    /// access point arn + accelerate = error@us-west-2
5070    #[test]
5071    fn test_205() {
5072        let params = crate::config::endpoint::Params::builder()
5073            .accelerate(true)
5074            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5075            .force_path_style(false)
5076            .region("us-west-2".to_string())
5077            .use_dual_stack(false)
5078            .use_fips(false)
5079            .build()
5080            .expect("invalid params");
5081        let resolver = crate::config::endpoint::DefaultResolver::new();
5082        let endpoint = resolver.resolve_endpoint(&params);
5083        let error =
5084            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@us-west-2]");
5085        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
5086    }
5087
5088    /// access point arn + FIPS + DualStack@us-west-2
5089    #[test]
5090    fn test_206() {
5091        let params = crate::config::endpoint::Params::builder()
5092            .accelerate(false)
5093            .bucket("arn:aws:s3:us-west-2:123456789012:accesspoint:myendpoint".to_string())
5094            .force_path_style(false)
5095            .region("us-west-2".to_string())
5096            .use_dual_stack(true)
5097            .use_fips(true)
5098            .build()
5099            .expect("invalid params");
5100        let resolver = crate::config::endpoint::DefaultResolver::new();
5101        let endpoint = resolver.resolve_endpoint(&params);
5102        let endpoint =
5103            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com");
5104        assert_eq!(
5105            endpoint,
5106            ::aws_smithy_types::endpoint::Endpoint::builder()
5107                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.us-west-2.amazonaws.com")
5108                .auth_scheme(
5109                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5110                        .put("disableDoubleEncoding", true)
5111                        .put("signingName", "s3".to_string())
5112                        .put("signingRegion", "us-west-2".to_string())
5113                )
5114                .build()
5115        );
5116    }
5117
5118    /// vanilla access point arn@cn-north-1
5119    #[test]
5120    fn test_207() {
5121        let params = crate::config::endpoint::Params::builder()
5122            .accelerate(false)
5123            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5124            .force_path_style(false)
5125            .region("cn-north-1".to_string())
5126            .use_dual_stack(false)
5127            .use_fips(false)
5128            .build()
5129            .expect("invalid params");
5130        let resolver = crate::config::endpoint::DefaultResolver::new();
5131        let endpoint = resolver.resolve_endpoint(&params);
5132        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.cn-north-1.amazonaws.com.cn");
5133        assert_eq!(
5134            endpoint,
5135            ::aws_smithy_types::endpoint::Endpoint::builder()
5136                .url("https://myendpoint-123456789012.s3-accesspoint.cn-north-1.amazonaws.com.cn")
5137                .auth_scheme(
5138                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5139                        .put("disableDoubleEncoding", true)
5140                        .put("signingName", "s3".to_string())
5141                        .put("signingRegion", "cn-north-1".to_string())
5142                )
5143                .build()
5144        );
5145    }
5146
5147    /// access point arn + FIPS@cn-north-1
5148    #[test]
5149    fn test_208() {
5150        let params = crate::config::endpoint::Params::builder()
5151            .accelerate(false)
5152            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5153            .force_path_style(false)
5154            .region("cn-north-1".to_string())
5155            .use_dual_stack(false)
5156            .use_fips(true)
5157            .build()
5158            .expect("invalid params");
5159        let resolver = crate::config::endpoint::DefaultResolver::new();
5160        let endpoint = resolver.resolve_endpoint(&params);
5161        let error = endpoint.expect_err("expected error: Partition does not support FIPS [access point arn + FIPS@cn-north-1]");
5162        assert_eq!(format!("{}", error), "Partition does not support FIPS")
5163    }
5164
5165    /// access point arn + accelerate = error@cn-north-1
5166    #[test]
5167    fn test_209() {
5168        let params = crate::config::endpoint::Params::builder()
5169            .accelerate(true)
5170            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5171            .force_path_style(false)
5172            .region("cn-north-1".to_string())
5173            .use_dual_stack(false)
5174            .use_fips(false)
5175            .build()
5176            .expect("invalid params");
5177        let resolver = crate::config::endpoint::DefaultResolver::new();
5178        let endpoint = resolver.resolve_endpoint(&params);
5179        let error =
5180            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@cn-north-1]");
5181        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
5182    }
5183
5184    /// access point arn + FIPS + DualStack@cn-north-1
5185    #[test]
5186    fn test_210() {
5187        let params = crate::config::endpoint::Params::builder()
5188            .accelerate(false)
5189            .bucket("arn:aws-cn:s3:cn-north-1:123456789012:accesspoint:myendpoint".to_string())
5190            .force_path_style(false)
5191            .region("cn-north-1".to_string())
5192            .use_dual_stack(true)
5193            .use_fips(true)
5194            .build()
5195            .expect("invalid params");
5196        let resolver = crate::config::endpoint::DefaultResolver::new();
5197        let endpoint = resolver.resolve_endpoint(&params);
5198        let error = endpoint.expect_err("expected error: Partition does not support FIPS [access point arn + FIPS + DualStack@cn-north-1]");
5199        assert_eq!(format!("{}", error), "Partition does not support FIPS")
5200    }
5201
5202    /// vanilla access point arn@af-south-1
5203    #[test]
5204    fn test_211() {
5205        let params = crate::config::endpoint::Params::builder()
5206            .accelerate(false)
5207            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5208            .force_path_style(false)
5209            .region("af-south-1".to_string())
5210            .use_dual_stack(false)
5211            .use_fips(false)
5212            .build()
5213            .expect("invalid params");
5214        let resolver = crate::config::endpoint::DefaultResolver::new();
5215        let endpoint = resolver.resolve_endpoint(&params);
5216        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint.af-south-1.amazonaws.com");
5217        assert_eq!(
5218            endpoint,
5219            ::aws_smithy_types::endpoint::Endpoint::builder()
5220                .url("https://myendpoint-123456789012.s3-accesspoint.af-south-1.amazonaws.com")
5221                .auth_scheme(
5222                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5223                        .put("disableDoubleEncoding", true)
5224                        .put("signingName", "s3".to_string())
5225                        .put("signingRegion", "af-south-1".to_string())
5226                )
5227                .build()
5228        );
5229    }
5230
5231    /// access point arn + FIPS@af-south-1
5232    #[test]
5233    fn test_212() {
5234        let params = crate::config::endpoint::Params::builder()
5235            .accelerate(false)
5236            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5237            .force_path_style(false)
5238            .region("af-south-1".to_string())
5239            .use_dual_stack(false)
5240            .use_fips(true)
5241            .build()
5242            .expect("invalid params");
5243        let resolver = crate::config::endpoint::DefaultResolver::new();
5244        let endpoint = resolver.resolve_endpoint(&params);
5245        let endpoint = endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.af-south-1.amazonaws.com");
5246        assert_eq!(
5247            endpoint,
5248            ::aws_smithy_types::endpoint::Endpoint::builder()
5249                .url("https://myendpoint-123456789012.s3-accesspoint-fips.af-south-1.amazonaws.com")
5250                .auth_scheme(
5251                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5252                        .put("disableDoubleEncoding", true)
5253                        .put("signingName", "s3".to_string())
5254                        .put("signingRegion", "af-south-1".to_string())
5255                )
5256                .build()
5257        );
5258    }
5259
5260    /// access point arn + accelerate = error@af-south-1
5261    #[test]
5262    fn test_213() {
5263        let params = crate::config::endpoint::Params::builder()
5264            .accelerate(true)
5265            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5266            .force_path_style(false)
5267            .region("af-south-1".to_string())
5268            .use_dual_stack(false)
5269            .use_fips(false)
5270            .build()
5271            .expect("invalid params");
5272        let resolver = crate::config::endpoint::DefaultResolver::new();
5273        let endpoint = resolver.resolve_endpoint(&params);
5274        let error =
5275            endpoint.expect_err("expected error: Access Points do not support S3 Accelerate [access point arn + accelerate = error@af-south-1]");
5276        assert_eq!(format!("{}", error), "Access Points do not support S3 Accelerate")
5277    }
5278
5279    /// access point arn + FIPS + DualStack@af-south-1
5280    #[test]
5281    fn test_214() {
5282        let params = crate::config::endpoint::Params::builder()
5283            .accelerate(false)
5284            .bucket("arn:aws:s3:af-south-1:123456789012:accesspoint:myendpoint".to_string())
5285            .force_path_style(false)
5286            .region("af-south-1".to_string())
5287            .use_dual_stack(true)
5288            .use_fips(true)
5289            .build()
5290            .expect("invalid params");
5291        let resolver = crate::config::endpoint::DefaultResolver::new();
5292        let endpoint = resolver.resolve_endpoint(&params);
5293        let endpoint =
5294            endpoint.expect("Expected valid endpoint: https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.af-south-1.amazonaws.com");
5295        assert_eq!(
5296            endpoint,
5297            ::aws_smithy_types::endpoint::Endpoint::builder()
5298                .url("https://myendpoint-123456789012.s3-accesspoint-fips.dualstack.af-south-1.amazonaws.com")
5299                .auth_scheme(
5300                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5301                        .put("disableDoubleEncoding", true)
5302                        .put("signingName", "s3".to_string())
5303                        .put("signingRegion", "af-south-1".to_string())
5304                )
5305                .build()
5306        );
5307    }
5308
5309    /// S3 outposts vanilla test
5310    #[test]
5311    fn test_215() {
5312        let params = crate::config::endpoint::Params::builder()
5313            .region("us-west-2".to_string())
5314            .use_fips(false)
5315            .use_dual_stack(false)
5316            .accelerate(false)
5317            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
5318            .build()
5319            .expect("invalid params");
5320        let resolver = crate::config::endpoint::DefaultResolver::new();
5321        let endpoint = resolver.resolve_endpoint(&params);
5322        let endpoint =
5323            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-west-2.amazonaws.com");
5324        assert_eq!(
5325            endpoint,
5326            ::aws_smithy_types::endpoint::Endpoint::builder()
5327                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-west-2.amazonaws.com")
5328                .auth_scheme(
5329                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
5330                        .put("disableDoubleEncoding", true)
5331                        .put("signingName", "s3-outposts".to_string())
5332                        .put("signingRegionSet", vec!["*".to_string().into()])
5333                )
5334                .auth_scheme(
5335                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5336                        .put("disableDoubleEncoding", true)
5337                        .put("signingName", "s3-outposts".to_string())
5338                        .put("signingRegion", "us-west-2".to_string())
5339                )
5340                .build()
5341        );
5342    }
5343
5344    /// S3 outposts custom endpoint
5345    #[test]
5346    fn test_216() {
5347        let params = crate::config::endpoint::Params::builder()
5348            .region("us-west-2".to_string())
5349            .use_fips(false)
5350            .use_dual_stack(false)
5351            .accelerate(false)
5352            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
5353            .endpoint("https://example.amazonaws.com".to_string())
5354            .build()
5355            .expect("invalid params");
5356        let resolver = crate::config::endpoint::DefaultResolver::new();
5357        let endpoint = resolver.resolve_endpoint(&params);
5358        let endpoint = endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.example.amazonaws.com");
5359        assert_eq!(
5360            endpoint,
5361            ::aws_smithy_types::endpoint::Endpoint::builder()
5362                .url("https://reports-123456789012.op-01234567890123456.example.amazonaws.com")
5363                .auth_scheme(
5364                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
5365                        .put("disableDoubleEncoding", true)
5366                        .put("signingName", "s3-outposts".to_string())
5367                        .put("signingRegionSet", vec!["*".to_string().into()])
5368                )
5369                .auth_scheme(
5370                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5371                        .put("disableDoubleEncoding", true)
5372                        .put("signingName", "s3-outposts".to_string())
5373                        .put("signingRegion", "us-west-2".to_string())
5374                )
5375                .build()
5376        );
5377    }
5378
5379    /// outposts arn with region mismatch and UseArnRegion=false
5380    #[test]
5381    fn test_217() {
5382        let params = crate::config::endpoint::Params::builder()
5383            .accelerate(false)
5384            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
5385            .force_path_style(false)
5386            .use_arn_region(false)
5387            .region("us-west-2".to_string())
5388            .use_dual_stack(false)
5389            .use_fips(false)
5390            .build()
5391            .expect("invalid params");
5392        let resolver = crate::config::endpoint::DefaultResolver::new();
5393        let endpoint = resolver.resolve_endpoint(&params);
5394        let error = endpoint.expect_err("expected error: 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]");
5395        assert_eq!(
5396            format!("{}", error),
5397            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
5398        )
5399    }
5400
5401    /// outposts arn with region mismatch, custom region and UseArnRegion=false
5402    #[test]
5403    fn test_218() {
5404        let params = crate::config::endpoint::Params::builder()
5405            .accelerate(false)
5406            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
5407            .endpoint("https://example.com".to_string())
5408            .force_path_style(false)
5409            .use_arn_region(false)
5410            .region("us-west-2".to_string())
5411            .use_dual_stack(false)
5412            .use_fips(false)
5413            .build()
5414            .expect("invalid params");
5415        let resolver = crate::config::endpoint::DefaultResolver::new();
5416        let endpoint = resolver.resolve_endpoint(&params);
5417        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]");
5418        assert_eq!(
5419            format!("{}", error),
5420            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
5421        )
5422    }
5423
5424    /// outposts arn with region mismatch and UseArnRegion=true
5425    #[test]
5426    fn test_219() {
5427        let params = crate::config::endpoint::Params::builder()
5428            .accelerate(false)
5429            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
5430            .force_path_style(false)
5431            .use_arn_region(true)
5432            .region("us-west-2".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 endpoint =
5440            endpoint.expect("Expected valid endpoint: https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
5441        assert_eq!(
5442            endpoint,
5443            ::aws_smithy_types::endpoint::Endpoint::builder()
5444                .url("https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
5445                .auth_scheme(
5446                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
5447                        .put("disableDoubleEncoding", true)
5448                        .put("signingName", "s3-outposts".to_string())
5449                        .put("signingRegionSet", vec!["*".to_string().into()])
5450                )
5451                .auth_scheme(
5452                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5453                        .put("disableDoubleEncoding", true)
5454                        .put("signingName", "s3-outposts".to_string())
5455                        .put("signingRegion", "us-east-1".to_string())
5456                )
5457                .build()
5458        );
5459    }
5460
5461    /// outposts arn with region mismatch and UseArnRegion unset
5462    #[test]
5463    fn test_220() {
5464        let params = crate::config::endpoint::Params::builder()
5465            .accelerate(false)
5466            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
5467            .force_path_style(false)
5468            .region("us-west-2".to_string())
5469            .use_dual_stack(false)
5470            .use_fips(false)
5471            .build()
5472            .expect("invalid params");
5473        let resolver = crate::config::endpoint::DefaultResolver::new();
5474        let endpoint = resolver.resolve_endpoint(&params);
5475        let endpoint =
5476            endpoint.expect("Expected valid endpoint: https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
5477        assert_eq!(
5478            endpoint,
5479            ::aws_smithy_types::endpoint::Endpoint::builder()
5480                .url("https://myaccesspoint-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
5481                .auth_scheme(
5482                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
5483                        .put("disableDoubleEncoding", true)
5484                        .put("signingName", "s3-outposts".to_string())
5485                        .put("signingRegionSet", vec!["*".to_string().into()])
5486                )
5487                .auth_scheme(
5488                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5489                        .put("disableDoubleEncoding", true)
5490                        .put("signingName", "s3-outposts".to_string())
5491                        .put("signingRegion", "us-east-1".to_string())
5492                )
5493                .build()
5494        );
5495    }
5496
5497    /// outposts arn with partition mismatch and UseArnRegion=true
5498    #[test]
5499    fn test_221() {
5500        let params = crate::config::endpoint::Params::builder()
5501            .accelerate(false)
5502            .bucket("arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_string())
5503            .force_path_style(false)
5504            .use_arn_region(true)
5505            .region("us-west-2".to_string())
5506            .use_dual_stack(false)
5507            .use_fips(false)
5508            .build()
5509            .expect("invalid params");
5510        let resolver = crate::config::endpoint::DefaultResolver::new();
5511        let endpoint = resolver.resolve_endpoint(&params);
5512        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]");
5513        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`")
5514    }
5515
5516    /// ARN with UseGlobalEndpoint and use-east-1 region uses the regional endpoint
5517    #[test]
5518    fn test_222() {
5519        let params = crate::config::endpoint::Params::builder()
5520            .region("us-east-1".to_string())
5521            .use_global_endpoint(true)
5522            .use_fips(false)
5523            .use_dual_stack(false)
5524            .accelerate(false)
5525            .bucket("arn:aws:s3-outposts:us-east-1:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
5526            .build()
5527            .expect("invalid params");
5528        let resolver = crate::config::endpoint::DefaultResolver::new();
5529        let endpoint = resolver.resolve_endpoint(&params);
5530        let endpoint =
5531            endpoint.expect("Expected valid endpoint: https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com");
5532        assert_eq!(
5533            endpoint,
5534            ::aws_smithy_types::endpoint::Endpoint::builder()
5535                .url("https://reports-123456789012.op-01234567890123456.s3-outposts.us-east-1.amazonaws.com")
5536                .auth_scheme(
5537                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
5538                        .put("disableDoubleEncoding", true)
5539                        .put("signingName", "s3-outposts".to_string())
5540                        .put("signingRegionSet", vec!["*".to_string().into()])
5541                )
5542                .auth_scheme(
5543                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5544                        .put("disableDoubleEncoding", true)
5545                        .put("signingName", "s3-outposts".to_string())
5546                        .put("signingRegion", "us-east-1".to_string())
5547                )
5548                .build()
5549        );
5550    }
5551
5552    /// S3 outposts does not support dualstack
5553    #[test]
5554    fn test_223() {
5555        let params = crate::config::endpoint::Params::builder()
5556            .region("us-east-1".to_string())
5557            .use_fips(false)
5558            .use_dual_stack(true)
5559            .accelerate(false)
5560            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
5561            .build()
5562            .expect("invalid params");
5563        let resolver = crate::config::endpoint::DefaultResolver::new();
5564        let endpoint = resolver.resolve_endpoint(&params);
5565        let error = endpoint.expect_err("expected error: S3 Outposts does not support Dual-stack [S3 outposts does not support dualstack]");
5566        assert_eq!(format!("{}", error), "S3 Outposts does not support Dual-stack")
5567    }
5568
5569    /// S3 outposts does not support fips
5570    #[test]
5571    fn test_224() {
5572        let params = crate::config::endpoint::Params::builder()
5573            .region("us-east-1".to_string())
5574            .use_fips(true)
5575            .use_dual_stack(false)
5576            .accelerate(false)
5577            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
5578            .build()
5579            .expect("invalid params");
5580        let resolver = crate::config::endpoint::DefaultResolver::new();
5581        let endpoint = resolver.resolve_endpoint(&params);
5582        let error = endpoint.expect_err("expected error: S3 Outposts does not support FIPS [S3 outposts does not support fips]");
5583        assert_eq!(format!("{}", error), "S3 Outposts does not support FIPS")
5584    }
5585
5586    /// S3 outposts does not support accelerate
5587    #[test]
5588    fn test_225() {
5589        let params = crate::config::endpoint::Params::builder()
5590            .region("us-east-1".to_string())
5591            .use_fips(false)
5592            .use_dual_stack(false)
5593            .accelerate(true)
5594            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost/op-01234567890123456/accesspoint/reports".to_string())
5595            .build()
5596            .expect("invalid params");
5597        let resolver = crate::config::endpoint::DefaultResolver::new();
5598        let endpoint = resolver.resolve_endpoint(&params);
5599        let error = endpoint.expect_err("expected error: S3 Outposts does not support S3 Accelerate [S3 outposts does not support accelerate]");
5600        assert_eq!(format!("{}", error), "S3 Outposts does not support S3 Accelerate")
5601    }
5602
5603    /// validates against subresource
5604    #[test]
5605    fn test_226() {
5606        let params = crate::config::endpoint::Params::builder()
5607            .region("us-west-2".to_string())
5608            .use_fips(false)
5609            .use_dual_stack(false)
5610            .accelerate(false)
5611            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:mybucket:object:foo".to_string())
5612            .build()
5613            .expect("invalid params");
5614        let resolver = crate::config::endpoint::DefaultResolver::new();
5615        let endpoint = resolver.resolve_endpoint(&params);
5616        let error =
5617            endpoint.expect_err("expected error: Invalid Arn: Outpost Access Point ARN contains sub resources [validates against subresource]");
5618        assert_eq!(format!("{}", error), "Invalid Arn: Outpost Access Point ARN contains sub resources")
5619    }
5620
5621    /// validates against access point host label
5622    #[test]
5623    fn test_227() {
5624        let params = crate::config::endpoint::Params::builder()
5625            .region("us-west-2".to_string())
5626            .use_fips(false)
5627            .use_dual_stack(false)
5628            .accelerate(false)
5629            .bucket("arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:invalid.bucket#".to_string())
5630            .build()
5631            .expect("invalid params");
5632        let resolver = crate::config::endpoint::DefaultResolver::new();
5633        let endpoint = resolver.resolve_endpoint(&params);
5634        let error = endpoint.expect_err("expected error: Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `invalid.bucket#` [validates against access point host label]");
5635        assert_eq!(
5636            format!("{}", error),
5637            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `invalid.bucket#`"
5638        )
5639    }
5640
5641    /// object lambda @us-east-1
5642    #[test]
5643    fn test_228() {
5644        let params = crate::config::endpoint::Params::builder()
5645            .region("us-east-1".to_string())
5646            .use_fips(false)
5647            .use_dual_stack(false)
5648            .accelerate(false)
5649            .use_arn_region(false)
5650            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
5651            .build()
5652            .expect("invalid params");
5653        let resolver = crate::config::endpoint::DefaultResolver::new();
5654        let endpoint = resolver.resolve_endpoint(&params);
5655        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
5656        assert_eq!(
5657            endpoint,
5658            ::aws_smithy_types::endpoint::Endpoint::builder()
5659                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
5660                .auth_scheme(
5661                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5662                        .put("disableDoubleEncoding", true)
5663                        .put("signingName", "s3-object-lambda".to_string())
5664                        .put("signingRegion", "us-east-1".to_string())
5665                )
5666                .build()
5667        );
5668    }
5669
5670    /// object lambda @us-west-2
5671    #[test]
5672    fn test_229() {
5673        let params = crate::config::endpoint::Params::builder()
5674            .region("us-west-2".to_string())
5675            .use_fips(false)
5676            .use_dual_stack(false)
5677            .accelerate(false)
5678            .use_arn_region(false)
5679            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
5680            .build()
5681            .expect("invalid params");
5682        let resolver = crate::config::endpoint::DefaultResolver::new();
5683        let endpoint = resolver.resolve_endpoint(&params);
5684        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com");
5685        assert_eq!(
5686            endpoint,
5687            ::aws_smithy_types::endpoint::Endpoint::builder()
5688                .url("https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com")
5689                .auth_scheme(
5690                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5691                        .put("disableDoubleEncoding", true)
5692                        .put("signingName", "s3-object-lambda".to_string())
5693                        .put("signingRegion", "us-west-2".to_string())
5694                )
5695                .build()
5696        );
5697    }
5698
5699    /// object lambda, colon resource deliminator @us-west-2
5700    #[test]
5701    fn test_230() {
5702        let params = crate::config::endpoint::Params::builder()
5703            .region("us-west-2".to_string())
5704            .use_fips(false)
5705            .use_dual_stack(false)
5706            .accelerate(false)
5707            .use_arn_region(false)
5708            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:mybanner".to_string())
5709            .build()
5710            .expect("invalid params");
5711        let resolver = crate::config::endpoint::DefaultResolver::new();
5712        let endpoint = resolver.resolve_endpoint(&params);
5713        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com");
5714        assert_eq!(
5715            endpoint,
5716            ::aws_smithy_types::endpoint::Endpoint::builder()
5717                .url("https://mybanner-123456789012.s3-object-lambda.us-west-2.amazonaws.com")
5718                .auth_scheme(
5719                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5720                        .put("disableDoubleEncoding", true)
5721                        .put("signingName", "s3-object-lambda".to_string())
5722                        .put("signingRegion", "us-west-2".to_string())
5723                )
5724                .build()
5725        );
5726    }
5727
5728    /// object lambda @us-east-1, client region us-west-2, useArnRegion=true
5729    #[test]
5730    fn test_231() {
5731        let params = crate::config::endpoint::Params::builder()
5732            .region("us-west-2".to_string())
5733            .use_fips(false)
5734            .use_dual_stack(false)
5735            .accelerate(false)
5736            .use_arn_region(true)
5737            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
5738            .build()
5739            .expect("invalid params");
5740        let resolver = crate::config::endpoint::DefaultResolver::new();
5741        let endpoint = resolver.resolve_endpoint(&params);
5742        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
5743        assert_eq!(
5744            endpoint,
5745            ::aws_smithy_types::endpoint::Endpoint::builder()
5746                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
5747                .auth_scheme(
5748                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5749                        .put("disableDoubleEncoding", true)
5750                        .put("signingName", "s3-object-lambda".to_string())
5751                        .put("signingRegion", "us-east-1".to_string())
5752                )
5753                .build()
5754        );
5755    }
5756
5757    /// object lambda @us-east-1, client region s3-external-1, useArnRegion=true
5758    #[test]
5759    fn test_232() {
5760        let params = crate::config::endpoint::Params::builder()
5761            .region("s3-external-1".to_string())
5762            .use_fips(false)
5763            .use_dual_stack(false)
5764            .accelerate(false)
5765            .use_arn_region(true)
5766            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
5767            .build()
5768            .expect("invalid params");
5769        let resolver = crate::config::endpoint::DefaultResolver::new();
5770        let endpoint = resolver.resolve_endpoint(&params);
5771        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
5772        assert_eq!(
5773            endpoint,
5774            ::aws_smithy_types::endpoint::Endpoint::builder()
5775                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
5776                .auth_scheme(
5777                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5778                        .put("disableDoubleEncoding", true)
5779                        .put("signingName", "s3-object-lambda".to_string())
5780                        .put("signingRegion", "us-east-1".to_string())
5781                )
5782                .build()
5783        );
5784    }
5785
5786    /// object lambda @us-east-1, client region s3-external-1, useArnRegion=false
5787    #[test]
5788    fn test_233() {
5789        let params = crate::config::endpoint::Params::builder()
5790            .region("s3-external-1".to_string())
5791            .use_fips(false)
5792            .use_dual_stack(false)
5793            .accelerate(false)
5794            .use_arn_region(false)
5795            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
5796            .build()
5797            .expect("invalid params");
5798        let resolver = crate::config::endpoint::DefaultResolver::new();
5799        let endpoint = resolver.resolve_endpoint(&params);
5800        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]");
5801        assert_eq!(
5802            format!("{}", error),
5803            "Invalid configuration: region from ARN `us-east-1` does not match client region `s3-external-1` and UseArnRegion is `false`"
5804        )
5805    }
5806
5807    /// object lambda @us-east-1, client region aws-global, useArnRegion=true
5808    #[test]
5809    fn test_234() {
5810        let params = crate::config::endpoint::Params::builder()
5811            .region("aws-global".to_string())
5812            .use_fips(false)
5813            .use_dual_stack(false)
5814            .accelerate(false)
5815            .use_arn_region(true)
5816            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
5817            .build()
5818            .expect("invalid params");
5819        let resolver = crate::config::endpoint::DefaultResolver::new();
5820        let endpoint = resolver.resolve_endpoint(&params);
5821        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com");
5822        assert_eq!(
5823            endpoint,
5824            ::aws_smithy_types::endpoint::Endpoint::builder()
5825                .url("https://mybanner-123456789012.s3-object-lambda.us-east-1.amazonaws.com")
5826                .auth_scheme(
5827                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5828                        .put("disableDoubleEncoding", true)
5829                        .put("signingName", "s3-object-lambda".to_string())
5830                        .put("signingRegion", "us-east-1".to_string())
5831                )
5832                .build()
5833        );
5834    }
5835
5836    /// object lambda @us-east-1, client region aws-global, useArnRegion=false
5837    #[test]
5838    fn test_235() {
5839        let params = crate::config::endpoint::Params::builder()
5840            .region("aws-global".to_string())
5841            .use_fips(false)
5842            .use_dual_stack(false)
5843            .accelerate(false)
5844            .use_arn_region(false)
5845            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
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: 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]");
5851        assert_eq!(
5852            format!("{}", error),
5853            "Invalid configuration: region from ARN `us-east-1` does not match client region `aws-global` and UseArnRegion is `false`"
5854        )
5855    }
5856
5857    /// object lambda @cn-north-1, client region us-west-2 (cross partition), useArnRegion=true
5858    #[test]
5859    fn test_236() {
5860        let params = crate::config::endpoint::Params::builder()
5861            .region("aws-global".to_string())
5862            .use_fips(false)
5863            .use_dual_stack(false)
5864            .accelerate(false)
5865            .use_arn_region(true)
5866            .bucket("arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner".to_string())
5867            .build()
5868            .expect("invalid params");
5869        let resolver = crate::config::endpoint::DefaultResolver::new();
5870        let endpoint = resolver.resolve_endpoint(&params);
5871        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]");
5872        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`")
5873    }
5874
5875    /// object lambda with dualstack
5876    #[test]
5877    fn test_237() {
5878        let params = crate::config::endpoint::Params::builder()
5879            .region("us-west-2".to_string())
5880            .use_fips(false)
5881            .use_dual_stack(true)
5882            .accelerate(false)
5883            .use_arn_region(false)
5884            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
5885            .build()
5886            .expect("invalid params");
5887        let resolver = crate::config::endpoint::DefaultResolver::new();
5888        let endpoint = resolver.resolve_endpoint(&params);
5889        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support Dual-stack [object lambda with dualstack]");
5890        assert_eq!(format!("{}", error), "S3 Object Lambda does not support Dual-stack")
5891    }
5892
5893    /// object lambda @us-gov-east-1
5894    #[test]
5895    fn test_238() {
5896        let params = crate::config::endpoint::Params::builder()
5897            .region("us-gov-east-1".to_string())
5898            .use_fips(false)
5899            .use_dual_stack(false)
5900            .accelerate(false)
5901            .use_arn_region(false)
5902            .bucket("arn:aws-us-gov:s3-object-lambda:us-gov-east-1:123456789012:accesspoint/mybanner".to_string())
5903            .build()
5904            .expect("invalid params");
5905        let resolver = crate::config::endpoint::DefaultResolver::new();
5906        let endpoint = resolver.resolve_endpoint(&params);
5907        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda.us-gov-east-1.amazonaws.com");
5908        assert_eq!(
5909            endpoint,
5910            ::aws_smithy_types::endpoint::Endpoint::builder()
5911                .url("https://mybanner-123456789012.s3-object-lambda.us-gov-east-1.amazonaws.com")
5912                .auth_scheme(
5913                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5914                        .put("disableDoubleEncoding", true)
5915                        .put("signingName", "s3-object-lambda".to_string())
5916                        .put("signingRegion", "us-gov-east-1".to_string())
5917                )
5918                .build()
5919        );
5920    }
5921
5922    /// object lambda @us-gov-east-1, with fips
5923    #[test]
5924    fn test_239() {
5925        let params = crate::config::endpoint::Params::builder()
5926            .region("us-gov-east-1".to_string())
5927            .use_fips(true)
5928            .use_dual_stack(false)
5929            .accelerate(false)
5930            .use_arn_region(false)
5931            .bucket("arn:aws-us-gov:s3-object-lambda:us-gov-east-1:123456789012:accesspoint/mybanner".to_string())
5932            .build()
5933            .expect("invalid params");
5934        let resolver = crate::config::endpoint::DefaultResolver::new();
5935        let endpoint = resolver.resolve_endpoint(&params);
5936        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.s3-object-lambda-fips.us-gov-east-1.amazonaws.com");
5937        assert_eq!(
5938            endpoint,
5939            ::aws_smithy_types::endpoint::Endpoint::builder()
5940                .url("https://mybanner-123456789012.s3-object-lambda-fips.us-gov-east-1.amazonaws.com")
5941                .auth_scheme(
5942                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
5943                        .put("disableDoubleEncoding", true)
5944                        .put("signingName", "s3-object-lambda".to_string())
5945                        .put("signingRegion", "us-gov-east-1".to_string())
5946                )
5947                .build()
5948        );
5949    }
5950
5951    /// object lambda @cn-north-1, with fips
5952    #[test]
5953    fn test_240() {
5954        let params = crate::config::endpoint::Params::builder()
5955            .region("cn-north-1".to_string())
5956            .use_fips(true)
5957            .use_dual_stack(false)
5958            .accelerate(false)
5959            .use_arn_region(false)
5960            .bucket("arn:aws-cn:s3-object-lambda:cn-north-1:123456789012:accesspoint/mybanner".to_string())
5961            .build()
5962            .expect("invalid params");
5963        let resolver = crate::config::endpoint::DefaultResolver::new();
5964        let endpoint = resolver.resolve_endpoint(&params);
5965        let error = endpoint.expect_err("expected error: Partition does not support FIPS [object lambda @cn-north-1, with fips]");
5966        assert_eq!(format!("{}", error), "Partition does not support FIPS")
5967    }
5968
5969    /// object lambda with accelerate
5970    #[test]
5971    fn test_241() {
5972        let params = crate::config::endpoint::Params::builder()
5973            .region("us-west-2".to_string())
5974            .use_fips(false)
5975            .use_dual_stack(false)
5976            .accelerate(true)
5977            .use_arn_region(false)
5978            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
5979            .build()
5980            .expect("invalid params");
5981        let resolver = crate::config::endpoint::DefaultResolver::new();
5982        let endpoint = resolver.resolve_endpoint(&params);
5983        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support S3 Accelerate [object lambda with accelerate]");
5984        assert_eq!(format!("{}", error), "S3 Object Lambda does not support S3 Accelerate")
5985    }
5986
5987    /// object lambda with invalid arn - bad service and someresource
5988    #[test]
5989    fn test_242() {
5990        let params = crate::config::endpoint::Params::builder()
5991            .region("us-west-2".to_string())
5992            .use_fips(false)
5993            .use_dual_stack(false)
5994            .accelerate(false)
5995            .use_arn_region(false)
5996            .bucket("arn:aws:sqs:us-west-2:123456789012:someresource".to_string())
5997            .build()
5998            .expect("invalid params");
5999        let resolver = crate::config::endpoint::DefaultResolver::new();
6000        let endpoint = resolver.resolve_endpoint(&params);
6001        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]");
6002        assert_eq!(
6003            format!("{}", error),
6004            "Invalid ARN: Unrecognized format: arn:aws:sqs:us-west-2:123456789012:someresource (type: someresource)"
6005        )
6006    }
6007
6008    /// object lambda with invalid arn - invalid resource
6009    #[test]
6010    fn test_243() {
6011        let params = crate::config::endpoint::Params::builder()
6012            .region("us-west-2".to_string())
6013            .use_fips(false)
6014            .use_dual_stack(false)
6015            .accelerate(false)
6016            .use_arn_region(false)
6017            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:bucket_name:mybucket".to_string())
6018            .build()
6019            .expect("invalid params");
6020        let resolver = crate::config::endpoint::DefaultResolver::new();
6021        let endpoint = resolver.resolve_endpoint(&params);
6022        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]");
6023        assert_eq!(
6024            format!("{}", error),
6025            "Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `bucket_name`"
6026        )
6027    }
6028
6029    /// object lambda with invalid arn - missing region
6030    #[test]
6031    fn test_244() {
6032        let params = crate::config::endpoint::Params::builder()
6033            .region("us-west-2".to_string())
6034            .use_fips(false)
6035            .use_dual_stack(false)
6036            .accelerate(false)
6037            .use_arn_region(false)
6038            .bucket("arn:aws:s3-object-lambda::123456789012:accesspoint/mybanner".to_string())
6039            .build()
6040            .expect("invalid params");
6041        let resolver = crate::config::endpoint::DefaultResolver::new();
6042        let endpoint = resolver.resolve_endpoint(&params);
6043        let error =
6044            endpoint.expect_err("expected error: Invalid ARN: bucket ARN is missing a region [object lambda with invalid arn - missing region]");
6045        assert_eq!(format!("{}", error), "Invalid ARN: bucket ARN is missing a region")
6046    }
6047
6048    /// object lambda with invalid arn - missing account-id
6049    #[test]
6050    fn test_245() {
6051        let params = crate::config::endpoint::Params::builder()
6052            .region("us-west-2".to_string())
6053            .use_fips(false)
6054            .use_dual_stack(false)
6055            .accelerate(false)
6056            .use_arn_region(true)
6057            .bucket("arn:aws:s3-object-lambda:us-west-2::accesspoint/mybanner".to_string())
6058            .build()
6059            .expect("invalid params");
6060        let resolver = crate::config::endpoint::DefaultResolver::new();
6061        let endpoint = resolver.resolve_endpoint(&params);
6062        let error = endpoint.expect_err("expected error: Invalid ARN: Missing account id [object lambda with invalid arn - missing account-id]");
6063        assert_eq!(format!("{}", error), "Invalid ARN: Missing account id")
6064    }
6065
6066    /// object lambda with invalid arn - account id contains invalid characters
6067    #[test]
6068    fn test_246() {
6069        let params = crate::config::endpoint::Params::builder()
6070            .region("us-west-2".to_string())
6071            .use_fips(false)
6072            .use_dual_stack(false)
6073            .accelerate(false)
6074            .use_arn_region(true)
6075            .bucket("arn:aws:s3-object-lambda:us-west-2:123.45678.9012:accesspoint:mybucket".to_string())
6076            .build()
6077            .expect("invalid params");
6078        let resolver = crate::config::endpoint::DefaultResolver::new();
6079        let endpoint = resolver.resolve_endpoint(&params);
6080        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]");
6081        assert_eq!(
6082            format!("{}", error),
6083            "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `123.45678.9012`"
6084        )
6085    }
6086
6087    /// object lambda with invalid arn - missing access point name
6088    #[test]
6089    fn test_247() {
6090        let params = crate::config::endpoint::Params::builder()
6091            .region("us-west-2".to_string())
6092            .use_fips(false)
6093            .use_dual_stack(false)
6094            .accelerate(false)
6095            .use_arn_region(true)
6096            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint".to_string())
6097            .build()
6098            .expect("invalid params");
6099        let resolver = crate::config::endpoint::DefaultResolver::new();
6100        let endpoint = resolver.resolve_endpoint(&params);
6101        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]");
6102        assert_eq!(
6103            format!("{}", error),
6104            "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided"
6105        )
6106    }
6107
6108    /// object lambda with invalid arn - access point name contains invalid character: *
6109    #[test]
6110    fn test_248() {
6111        let params = crate::config::endpoint::Params::builder()
6112            .region("us-west-2".to_string())
6113            .use_fips(false)
6114            .use_dual_stack(false)
6115            .accelerate(false)
6116            .use_arn_region(true)
6117            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:*".to_string())
6118            .build()
6119            .expect("invalid params");
6120        let resolver = crate::config::endpoint::DefaultResolver::new();
6121        let endpoint = resolver.resolve_endpoint(&params);
6122        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: *]");
6123        assert_eq!(
6124            format!("{}", error),
6125            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `*`"
6126        )
6127    }
6128
6129    /// object lambda with invalid arn - access point name contains invalid character: .
6130    #[test]
6131    fn test_249() {
6132        let params = crate::config::endpoint::Params::builder()
6133            .region("us-west-2".to_string())
6134            .use_fips(false)
6135            .use_dual_stack(false)
6136            .accelerate(false)
6137            .use_arn_region(true)
6138            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:my.bucket".to_string())
6139            .build()
6140            .expect("invalid params");
6141        let resolver = crate::config::endpoint::DefaultResolver::new();
6142        let endpoint = resolver.resolve_endpoint(&params);
6143        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: .]");
6144        assert_eq!(
6145            format!("{}", error),
6146            "Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `my.bucket`"
6147        )
6148    }
6149
6150    /// object lambda with invalid arn - access point name contains sub resources
6151    #[test]
6152    fn test_250() {
6153        let params = crate::config::endpoint::Params::builder()
6154            .region("us-west-2".to_string())
6155            .use_fips(false)
6156            .use_dual_stack(false)
6157            .accelerate(false)
6158            .use_arn_region(true)
6159            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint:mybucket:object:foo".to_string())
6160            .build()
6161            .expect("invalid params");
6162        let resolver = crate::config::endpoint::DefaultResolver::new();
6163        let endpoint = resolver.resolve_endpoint(&params);
6164        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]");
6165        assert_eq!(
6166            format!("{}", error),
6167            "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`."
6168        )
6169    }
6170
6171    /// object lambda with custom endpoint
6172    #[test]
6173    fn test_251() {
6174        let params = crate::config::endpoint::Params::builder()
6175            .region("us-west-2".to_string())
6176            .use_fips(false)
6177            .use_dual_stack(false)
6178            .accelerate(false)
6179            .use_arn_region(false)
6180            .bucket("arn:aws:s3-object-lambda:us-west-2:123456789012:accesspoint/mybanner".to_string())
6181            .endpoint("https://my-endpoint.com".to_string())
6182            .build()
6183            .expect("invalid params");
6184        let resolver = crate::config::endpoint::DefaultResolver::new();
6185        let endpoint = resolver.resolve_endpoint(&params);
6186        let endpoint = endpoint.expect("Expected valid endpoint: https://mybanner-123456789012.my-endpoint.com");
6187        assert_eq!(
6188            endpoint,
6189            ::aws_smithy_types::endpoint::Endpoint::builder()
6190                .url("https://mybanner-123456789012.my-endpoint.com")
6191                .auth_scheme(
6192                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6193                        .put("disableDoubleEncoding", true)
6194                        .put("signingName", "s3-object-lambda".to_string())
6195                        .put("signingRegion", "us-west-2".to_string())
6196                )
6197                .build()
6198        );
6199    }
6200
6201    /// object lambda arn with region mismatch and UseArnRegion=false
6202    #[test]
6203    fn test_252() {
6204        let params = crate::config::endpoint::Params::builder()
6205            .accelerate(false)
6206            .bucket("arn:aws:s3-object-lambda:us-east-1:123456789012:accesspoint/mybanner".to_string())
6207            .force_path_style(false)
6208            .use_arn_region(false)
6209            .region("us-west-2".to_string())
6210            .use_dual_stack(false)
6211            .use_fips(false)
6212            .build()
6213            .expect("invalid params");
6214        let resolver = crate::config::endpoint::DefaultResolver::new();
6215        let endpoint = resolver.resolve_endpoint(&params);
6216        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]");
6217        assert_eq!(
6218            format!("{}", error),
6219            "Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"
6220        )
6221    }
6222
6223    /// WriteGetObjectResponse @ us-west-2
6224    #[test]
6225    fn test_253() {
6226        let params = crate::config::endpoint::Params::builder()
6227            .accelerate(false)
6228            .use_object_lambda_endpoint(true)
6229            .region("us-west-2".to_string())
6230            .use_dual_stack(false)
6231            .use_fips(false)
6232            .build()
6233            .expect("invalid params");
6234        let resolver = crate::config::endpoint::DefaultResolver::new();
6235        let endpoint = resolver.resolve_endpoint(&params);
6236        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-west-2.amazonaws.com");
6237        assert_eq!(
6238            endpoint,
6239            ::aws_smithy_types::endpoint::Endpoint::builder()
6240                .url("https://s3-object-lambda.us-west-2.amazonaws.com")
6241                .auth_scheme(
6242                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6243                        .put("disableDoubleEncoding", true)
6244                        .put("signingName", "s3-object-lambda".to_string())
6245                        .put("signingRegion", "us-west-2".to_string())
6246                )
6247                .build()
6248        );
6249    }
6250
6251    /// WriteGetObjectResponse with custom endpoint
6252    #[test]
6253    fn test_254() {
6254        let params = crate::config::endpoint::Params::builder()
6255            .accelerate(false)
6256            .use_object_lambda_endpoint(true)
6257            .endpoint("https://my-endpoint.com".to_string())
6258            .region("us-west-2".to_string())
6259            .use_dual_stack(false)
6260            .use_fips(false)
6261            .build()
6262            .expect("invalid params");
6263        let resolver = crate::config::endpoint::DefaultResolver::new();
6264        let endpoint = resolver.resolve_endpoint(&params);
6265        let endpoint = endpoint.expect("Expected valid endpoint: https://my-endpoint.com");
6266        assert_eq!(
6267            endpoint,
6268            ::aws_smithy_types::endpoint::Endpoint::builder()
6269                .url("https://my-endpoint.com")
6270                .auth_scheme(
6271                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6272                        .put("disableDoubleEncoding", true)
6273                        .put("signingName", "s3-object-lambda".to_string())
6274                        .put("signingRegion", "us-west-2".to_string())
6275                )
6276                .build()
6277        );
6278    }
6279
6280    /// WriteGetObjectResponse @ us-east-1
6281    #[test]
6282    fn test_255() {
6283        let params = crate::config::endpoint::Params::builder()
6284            .accelerate(false)
6285            .use_object_lambda_endpoint(true)
6286            .region("us-east-1".to_string())
6287            .use_dual_stack(false)
6288            .use_fips(false)
6289            .build()
6290            .expect("invalid params");
6291        let resolver = crate::config::endpoint::DefaultResolver::new();
6292        let endpoint = resolver.resolve_endpoint(&params);
6293        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-east-1.amazonaws.com");
6294        assert_eq!(
6295            endpoint,
6296            ::aws_smithy_types::endpoint::Endpoint::builder()
6297                .url("https://s3-object-lambda.us-east-1.amazonaws.com")
6298                .auth_scheme(
6299                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6300                        .put("disableDoubleEncoding", true)
6301                        .put("signingName", "s3-object-lambda".to_string())
6302                        .put("signingRegion", "us-east-1".to_string())
6303                )
6304                .build()
6305        );
6306    }
6307
6308    /// WriteGetObjectResponse with fips
6309    #[test]
6310    fn test_256() {
6311        let params = crate::config::endpoint::Params::builder()
6312            .accelerate(false)
6313            .use_object_lambda_endpoint(true)
6314            .region("us-east-1".to_string())
6315            .use_dual_stack(false)
6316            .use_fips(true)
6317            .build()
6318            .expect("invalid params");
6319        let resolver = crate::config::endpoint::DefaultResolver::new();
6320        let endpoint = resolver.resolve_endpoint(&params);
6321        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda-fips.us-east-1.amazonaws.com");
6322        assert_eq!(
6323            endpoint,
6324            ::aws_smithy_types::endpoint::Endpoint::builder()
6325                .url("https://s3-object-lambda-fips.us-east-1.amazonaws.com")
6326                .auth_scheme(
6327                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6328                        .put("disableDoubleEncoding", true)
6329                        .put("signingName", "s3-object-lambda".to_string())
6330                        .put("signingRegion", "us-east-1".to_string())
6331                )
6332                .build()
6333        );
6334    }
6335
6336    /// WriteGetObjectResponse with dualstack
6337    #[test]
6338    fn test_257() {
6339        let params = crate::config::endpoint::Params::builder()
6340            .accelerate(false)
6341            .use_object_lambda_endpoint(true)
6342            .region("us-east-1".to_string())
6343            .use_dual_stack(true)
6344            .use_fips(false)
6345            .build()
6346            .expect("invalid params");
6347        let resolver = crate::config::endpoint::DefaultResolver::new();
6348        let endpoint = resolver.resolve_endpoint(&params);
6349        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support Dual-stack [WriteGetObjectResponse with dualstack]");
6350        assert_eq!(format!("{}", error), "S3 Object Lambda does not support Dual-stack")
6351    }
6352
6353    /// WriteGetObjectResponse with accelerate
6354    #[test]
6355    fn test_258() {
6356        let params = crate::config::endpoint::Params::builder()
6357            .accelerate(true)
6358            .use_object_lambda_endpoint(true)
6359            .region("us-east-1".to_string())
6360            .use_dual_stack(false)
6361            .use_fips(false)
6362            .build()
6363            .expect("invalid params");
6364        let resolver = crate::config::endpoint::DefaultResolver::new();
6365        let endpoint = resolver.resolve_endpoint(&params);
6366        let error = endpoint.expect_err("expected error: S3 Object Lambda does not support S3 Accelerate [WriteGetObjectResponse with accelerate]");
6367        assert_eq!(format!("{}", error), "S3 Object Lambda does not support S3 Accelerate")
6368    }
6369
6370    /// WriteGetObjectResponse with fips in CN
6371    #[test]
6372    fn test_259() {
6373        let params = crate::config::endpoint::Params::builder()
6374            .accelerate(false)
6375            .region("cn-north-1".to_string())
6376            .use_object_lambda_endpoint(true)
6377            .use_dual_stack(false)
6378            .use_fips(true)
6379            .build()
6380            .expect("invalid params");
6381        let resolver = crate::config::endpoint::DefaultResolver::new();
6382        let endpoint = resolver.resolve_endpoint(&params);
6383        let error = endpoint.expect_err("expected error: Partition does not support FIPS [WriteGetObjectResponse with fips in CN]");
6384        assert_eq!(format!("{}", error), "Partition does not support FIPS")
6385    }
6386
6387    /// WriteGetObjectResponse with invalid partition
6388    #[test]
6389    fn test_260() {
6390        let params = crate::config::endpoint::Params::builder()
6391            .accelerate(false)
6392            .use_object_lambda_endpoint(true)
6393            .region("not a valid DNS name".to_string())
6394            .use_dual_stack(false)
6395            .use_fips(false)
6396            .build()
6397            .expect("invalid params");
6398        let resolver = crate::config::endpoint::DefaultResolver::new();
6399        let endpoint = resolver.resolve_endpoint(&params);
6400        let error =
6401            endpoint.expect_err("expected error: Invalid region: region was not a valid DNS name. [WriteGetObjectResponse with invalid partition]");
6402        assert_eq!(format!("{}", error), "Invalid region: region was not a valid DNS name.")
6403    }
6404
6405    /// WriteGetObjectResponse with an unknown partition
6406    #[test]
6407    fn test_261() {
6408        let params = crate::config::endpoint::Params::builder()
6409            .accelerate(false)
6410            .use_object_lambda_endpoint(true)
6411            .region("us-east.special".to_string())
6412            .use_dual_stack(false)
6413            .use_fips(false)
6414            .build()
6415            .expect("invalid params");
6416        let resolver = crate::config::endpoint::DefaultResolver::new();
6417        let endpoint = resolver.resolve_endpoint(&params);
6418        let endpoint = endpoint.expect("Expected valid endpoint: https://s3-object-lambda.us-east.special.amazonaws.com");
6419        assert_eq!(
6420            endpoint,
6421            ::aws_smithy_types::endpoint::Endpoint::builder()
6422                .url("https://s3-object-lambda.us-east.special.amazonaws.com")
6423                .auth_scheme(
6424                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6425                        .put("disableDoubleEncoding", true)
6426                        .put("signingName", "s3-object-lambda".to_string())
6427                        .put("signingRegion", "us-east.special".to_string())
6428                )
6429                .build()
6430        );
6431    }
6432
6433    /// S3 Outposts bucketAlias Real Outpost Prod us-west-1
6434    #[test]
6435    fn test_262() {
6436        let params = crate::config::endpoint::Params::builder()
6437            .region("us-west-1".to_string())
6438            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
6439            .use_fips(false)
6440            .use_dual_stack(false)
6441            .accelerate(false)
6442            .build()
6443            .expect("invalid params");
6444        let resolver = crate::config::endpoint::DefaultResolver::new();
6445        let endpoint = resolver.resolve_endpoint(&params);
6446        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.us-west-1.amazonaws.com");
6447        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")
6448    .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
6449    .put("disableDoubleEncoding", true)
6450    .put("signingName", "s3-outposts".to_string())
6451    .put("signingRegionSet", vec!["*".to_string().into()])
6452    )
6453    .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6454    .put("disableDoubleEncoding", true)
6455    .put("signingName", "s3-outposts".to_string())
6456    .put("signingRegion", "us-west-1".to_string())
6457    )
6458    .build());
6459    }
6460
6461    /// S3 Outposts bucketAlias Real Outpost Prod ap-east-1
6462    #[test]
6463    fn test_263() {
6464        let params = crate::config::endpoint::Params::builder()
6465            .region("ap-east-1".to_string())
6466            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
6467            .use_fips(false)
6468            .use_dual_stack(false)
6469            .accelerate(false)
6470            .build()
6471            .expect("invalid params");
6472        let resolver = crate::config::endpoint::DefaultResolver::new();
6473        let endpoint = resolver.resolve_endpoint(&params);
6474        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.op-0b1d075431d83bebd.s3-outposts.ap-east-1.amazonaws.com");
6475        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")
6476    .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
6477    .put("disableDoubleEncoding", true)
6478    .put("signingName", "s3-outposts".to_string())
6479    .put("signingRegionSet", vec!["*".to_string().into()])
6480    )
6481    .auth_scheme(::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6482    .put("disableDoubleEncoding", true)
6483    .put("signingName", "s3-outposts".to_string())
6484    .put("signingRegion", "ap-east-1".to_string())
6485    )
6486    .build());
6487    }
6488
6489    /// S3 Outposts bucketAlias Ec2 Outpost Prod us-east-1
6490    #[test]
6491    fn test_264() {
6492        let params = crate::config::endpoint::Params::builder()
6493            .region("us-east-1".to_string())
6494            .bucket("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
6495            .use_fips(false)
6496            .use_dual_stack(false)
6497            .accelerate(false)
6498            .build()
6499            .expect("invalid params");
6500        let resolver = crate::config::endpoint::DefaultResolver::new();
6501        let endpoint = resolver.resolve_endpoint(&params);
6502        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.us-east-1.amazonaws.com");
6503        assert_eq!(
6504            endpoint,
6505            ::aws_smithy_types::endpoint::Endpoint::builder()
6506                .url("https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.us-east-1.amazonaws.com")
6507                .auth_scheme(
6508                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
6509                        .put("disableDoubleEncoding", true)
6510                        .put("signingName", "s3-outposts".to_string())
6511                        .put("signingRegionSet", vec!["*".to_string().into()])
6512                )
6513                .auth_scheme(
6514                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6515                        .put("disableDoubleEncoding", true)
6516                        .put("signingName", "s3-outposts".to_string())
6517                        .put("signingRegion", "us-east-1".to_string())
6518                )
6519                .build()
6520        );
6521    }
6522
6523    /// S3 Outposts bucketAlias Ec2 Outpost Prod me-south-1
6524    #[test]
6525    fn test_265() {
6526        let params = crate::config::endpoint::Params::builder()
6527            .region("me-south-1".to_string())
6528            .bucket("test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
6529            .use_fips(false)
6530            .use_dual_stack(false)
6531            .accelerate(false)
6532            .build()
6533            .expect("invalid params");
6534        let resolver = crate::config::endpoint::DefaultResolver::new();
6535        let endpoint = resolver.resolve_endpoint(&params);
6536        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.me-south-1.amazonaws.com");
6537        assert_eq!(
6538            endpoint,
6539            ::aws_smithy_types::endpoint::Endpoint::builder()
6540                .url("https://test-accessp-e0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3.ec2.s3-outposts.me-south-1.amazonaws.com")
6541                .auth_scheme(
6542                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
6543                        .put("disableDoubleEncoding", true)
6544                        .put("signingName", "s3-outposts".to_string())
6545                        .put("signingRegionSet", vec!["*".to_string().into()])
6546                )
6547                .auth_scheme(
6548                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6549                        .put("disableDoubleEncoding", true)
6550                        .put("signingName", "s3-outposts".to_string())
6551                        .put("signingRegion", "me-south-1".to_string())
6552                )
6553                .build()
6554        );
6555    }
6556
6557    /// S3 Outposts bucketAlias Real Outpost Beta
6558    #[test]
6559    fn test_266() {
6560        let params = crate::config::endpoint::Params::builder()
6561            .region("us-east-1".to_string())
6562            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
6563            .endpoint("https://example.amazonaws.com".to_string())
6564            .use_fips(false)
6565            .use_dual_stack(false)
6566            .accelerate(false)
6567            .build()
6568            .expect("invalid params");
6569        let resolver = crate::config::endpoint::DefaultResolver::new();
6570        let endpoint = resolver.resolve_endpoint(&params);
6571        let endpoint = endpoint.expect("Expected valid endpoint: https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3.op-0b1d075431d83bebd.example.amazonaws.com");
6572        assert_eq!(
6573            endpoint,
6574            ::aws_smithy_types::endpoint::Endpoint::builder()
6575                .url("https://test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3.op-0b1d075431d83bebd.example.amazonaws.com")
6576                .auth_scheme(
6577                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
6578                        .put("disableDoubleEncoding", true)
6579                        .put("signingName", "s3-outposts".to_string())
6580                        .put("signingRegionSet", vec!["*".to_string().into()])
6581                )
6582                .auth_scheme(
6583                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6584                        .put("disableDoubleEncoding", true)
6585                        .put("signingName", "s3-outposts".to_string())
6586                        .put("signingRegion", "us-east-1".to_string())
6587                )
6588                .build()
6589        );
6590    }
6591
6592    /// S3 Outposts bucketAlias Ec2 Outpost Beta
6593    #[test]
6594    fn test_267() {
6595        let params = crate::config::endpoint::Params::builder()
6596            .region("us-east-1".to_string())
6597            .bucket("161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3".to_string())
6598            .endpoint("https://example.amazonaws.com".to_string())
6599            .use_fips(false)
6600            .use_dual_stack(false)
6601            .accelerate(false)
6602            .build()
6603            .expect("invalid params");
6604        let resolver = crate::config::endpoint::DefaultResolver::new();
6605        let endpoint = resolver.resolve_endpoint(&params);
6606        let endpoint = endpoint
6607            .expect("Expected valid endpoint: https://161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3.ec2.example.amazonaws.com");
6608        assert_eq!(
6609            endpoint,
6610            ::aws_smithy_types::endpoint::Endpoint::builder()
6611                .url("https://161743052723-e00000136899934034jeahy1t8gpzpbwjj8kb7beta0--op-s3.ec2.example.amazonaws.com")
6612                .auth_scheme(
6613                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a", 3)
6614                        .put("disableDoubleEncoding", true)
6615                        .put("signingName", "s3-outposts".to_string())
6616                        .put("signingRegionSet", vec!["*".to_string().into()])
6617                )
6618                .auth_scheme(
6619                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6620                        .put("disableDoubleEncoding", true)
6621                        .put("signingName", "s3-outposts".to_string())
6622                        .put("signingRegion", "us-east-1".to_string())
6623                )
6624                .build()
6625        );
6626    }
6627
6628    /// S3 Outposts bucketAlias - No endpoint set for beta
6629    #[test]
6630    fn test_268() {
6631        let params = crate::config::endpoint::Params::builder()
6632            .region("us-east-1".to_string())
6633            .bucket("test-accessp-o0b1d075431d83bebde8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
6634            .use_fips(false)
6635            .use_dual_stack(false)
6636            .accelerate(false)
6637            .build()
6638            .expect("invalid params");
6639        let resolver = crate::config::endpoint::DefaultResolver::new();
6640        let endpoint = resolver.resolve_endpoint(&params);
6641        let error = endpoint.expect_err(
6642            "expected error: Expected a endpoint to be specified but no endpoint was found [S3 Outposts bucketAlias - No endpoint set for beta]",
6643        );
6644        assert_eq!(format!("{}", error), "Expected a endpoint to be specified but no endpoint was found")
6645    }
6646
6647    /// S3 Outposts invalid bucket name
6648    #[test]
6649    fn test_269() {
6650        let params = crate::config::endpoint::Params::builder()
6651            .region("us-east-1".to_string())
6652            .bucket("test-accessp-o0b1de75431d83bebd/8xz5w8ijx1qzlbp3i3kbeta0--op-s3".to_string())
6653            .endpoint("https://example.amazonaws.com".to_string())
6654            .use_fips(false)
6655            .use_dual_stack(false)
6656            .accelerate(false)
6657            .build()
6658            .expect("invalid params");
6659        let resolver = crate::config::endpoint::DefaultResolver::new();
6660        let endpoint = resolver.resolve_endpoint(&params);
6661        let error =
6662            endpoint.expect_err("expected error: Invalid Outposts Bucket alias - it must be a valid bucket name. [S3 Outposts invalid bucket name]");
6663        assert_eq!(format!("{}", error), "Invalid Outposts Bucket alias - it must be a valid bucket name.")
6664    }
6665
6666    /// S3 Outposts bucketAlias Invalid hardware type
6667    #[test]
6668    fn test_270() {
6669        let params = crate::config::endpoint::Params::builder()
6670            .region("us-east-1".to_string())
6671            .bucket("test-accessp-h0000075431d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
6672            .use_fips(false)
6673            .use_dual_stack(false)
6674            .accelerate(false)
6675            .build()
6676            .expect("invalid params");
6677        let resolver = crate::config::endpoint::DefaultResolver::new();
6678        let endpoint = resolver.resolve_endpoint(&params);
6679        let error = endpoint.expect_err(
6680            "expected error: Unrecognized hardware type: \"Expected hardware type o or e but got h\" [S3 Outposts bucketAlias Invalid hardware type]",
6681        );
6682        assert_eq!(
6683            format!("{}", error),
6684            "Unrecognized hardware type: \"Expected hardware type o or e but got h\""
6685        )
6686    }
6687
6688    /// S3 Outposts bucketAlias Special character in Outpost Arn
6689    #[test]
6690    fn test_271() {
6691        let params = crate::config::endpoint::Params::builder()
6692            .region("us-east-1".to_string())
6693            .bucket("test-accessp-o00000754%1d83bebde8xz5w8ijx1qzlbp3i3kuse10--op-s3".to_string())
6694            .use_fips(false)
6695            .use_dual_stack(false)
6696            .accelerate(false)
6697            .build()
6698            .expect("invalid params");
6699        let resolver = crate::config::endpoint::DefaultResolver::new();
6700        let endpoint = resolver.resolve_endpoint(&params);
6701        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]");
6702        assert_eq!(
6703            format!("{}", error),
6704            "Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`."
6705        )
6706    }
6707
6708    /// S3 Outposts bucketAlias - No endpoint set for beta
6709    #[test]
6710    fn test_272() {
6711        let params = crate::config::endpoint::Params::builder()
6712            .region("us-east-1".to_string())
6713            .bucket("test-accessp-e0b1d075431d83bebde8xz5w8ijx1qzlbp3i3ebeta0--op-s3".to_string())
6714            .use_fips(false)
6715            .use_dual_stack(false)
6716            .accelerate(false)
6717            .build()
6718            .expect("invalid params");
6719        let resolver = crate::config::endpoint::DefaultResolver::new();
6720        let endpoint = resolver.resolve_endpoint(&params);
6721        let error = endpoint.expect_err(
6722            "expected error: Expected a endpoint to be specified but no endpoint was found [S3 Outposts bucketAlias - No endpoint set for beta]",
6723        );
6724        assert_eq!(format!("{}", error), "Expected a endpoint to be specified but no endpoint was found")
6725    }
6726
6727    /// S3 Snow with bucket
6728    #[test]
6729    fn test_273() {
6730        let params = crate::config::endpoint::Params::builder()
6731            .region("snow".to_string())
6732            .bucket("bucketName".to_string())
6733            .endpoint("http://10.0.1.12:433".to_string())
6734            .use_fips(false)
6735            .use_dual_stack(false)
6736            .accelerate(false)
6737            .build()
6738            .expect("invalid params");
6739        let resolver = crate::config::endpoint::DefaultResolver::new();
6740        let endpoint = resolver.resolve_endpoint(&params);
6741        let endpoint = endpoint.expect("Expected valid endpoint: http://10.0.1.12:433/bucketName");
6742        assert_eq!(
6743            endpoint,
6744            ::aws_smithy_types::endpoint::Endpoint::builder()
6745                .url("http://10.0.1.12:433/bucketName")
6746                .auth_scheme(
6747                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6748                        .put("disableDoubleEncoding", true)
6749                        .put("signingName", "s3".to_string())
6750                        .put("signingRegion", "snow".to_string())
6751                )
6752                .build()
6753        );
6754    }
6755
6756    /// S3 Snow without bucket
6757    #[test]
6758    fn test_274() {
6759        let params = crate::config::endpoint::Params::builder()
6760            .region("snow".to_string())
6761            .endpoint("https://10.0.1.12:433".to_string())
6762            .use_fips(false)
6763            .use_dual_stack(false)
6764            .accelerate(false)
6765            .build()
6766            .expect("invalid params");
6767        let resolver = crate::config::endpoint::DefaultResolver::new();
6768        let endpoint = resolver.resolve_endpoint(&params);
6769        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.1.12:433");
6770        assert_eq!(
6771            endpoint,
6772            ::aws_smithy_types::endpoint::Endpoint::builder()
6773                .url("https://10.0.1.12:433")
6774                .auth_scheme(
6775                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6776                        .put("disableDoubleEncoding", true)
6777                        .put("signingName", "s3".to_string())
6778                        .put("signingRegion", "snow".to_string())
6779                )
6780                .build()
6781        );
6782    }
6783
6784    /// S3 Snow no port
6785    #[test]
6786    fn test_275() {
6787        let params = crate::config::endpoint::Params::builder()
6788            .region("snow".to_string())
6789            .bucket("bucketName".to_string())
6790            .endpoint("http://10.0.1.12".to_string())
6791            .use_fips(false)
6792            .use_dual_stack(false)
6793            .accelerate(false)
6794            .build()
6795            .expect("invalid params");
6796        let resolver = crate::config::endpoint::DefaultResolver::new();
6797        let endpoint = resolver.resolve_endpoint(&params);
6798        let endpoint = endpoint.expect("Expected valid endpoint: http://10.0.1.12/bucketName");
6799        assert_eq!(
6800            endpoint,
6801            ::aws_smithy_types::endpoint::Endpoint::builder()
6802                .url("http://10.0.1.12/bucketName")
6803                .auth_scheme(
6804                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6805                        .put("disableDoubleEncoding", true)
6806                        .put("signingName", "s3".to_string())
6807                        .put("signingRegion", "snow".to_string())
6808                )
6809                .build()
6810        );
6811    }
6812
6813    /// S3 Snow dns endpoint
6814    #[test]
6815    fn test_276() {
6816        let params = crate::config::endpoint::Params::builder()
6817            .region("snow".to_string())
6818            .bucket("bucketName".to_string())
6819            .endpoint("https://amazonaws.com".to_string())
6820            .use_fips(false)
6821            .use_dual_stack(false)
6822            .accelerate(false)
6823            .build()
6824            .expect("invalid params");
6825        let resolver = crate::config::endpoint::DefaultResolver::new();
6826        let endpoint = resolver.resolve_endpoint(&params);
6827        let endpoint = endpoint.expect("Expected valid endpoint: https://amazonaws.com/bucketName");
6828        assert_eq!(
6829            endpoint,
6830            ::aws_smithy_types::endpoint::Endpoint::builder()
6831                .url("https://amazonaws.com/bucketName")
6832                .auth_scheme(
6833                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
6834                        .put("disableDoubleEncoding", true)
6835                        .put("signingName", "s3".to_string())
6836                        .put("signingRegion", "snow".to_string())
6837                )
6838                .build()
6839        );
6840    }
6841
6842    /// Data Plane with short zone name
6843    #[test]
6844    fn test_277() {
6845        let params = crate::config::endpoint::Params::builder()
6846            .region("us-east-1".to_string())
6847            .bucket("mybucket--abcd-ab1--x-s3".to_string())
6848            .use_fips(false)
6849            .use_dual_stack(false)
6850            .accelerate(false)
6851            .use_s3_express_control_endpoint(false)
6852            .build()
6853            .expect("invalid params");
6854        let resolver = crate::config::endpoint::DefaultResolver::new();
6855        let endpoint = resolver.resolve_endpoint(&params);
6856        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com");
6857        assert_eq!(
6858            endpoint,
6859            ::aws_smithy_types::endpoint::Endpoint::builder()
6860                .url("https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com")
6861                .auth_scheme(
6862                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
6863                        .put("disableDoubleEncoding", true)
6864                        .put("signingName", "s3express".to_string())
6865                        .put("signingRegion", "us-east-1".to_string())
6866                )
6867                .property("backend", "S3Express".to_string())
6868                .build()
6869        );
6870    }
6871
6872    /// Data Plane with short zone name china region
6873    #[test]
6874    fn test_278() {
6875        let params = crate::config::endpoint::Params::builder()
6876            .region("cn-north-1".to_string())
6877            .bucket("mybucket--abcd-ab1--x-s3".to_string())
6878            .use_fips(false)
6879            .use_dual_stack(false)
6880            .accelerate(false)
6881            .use_s3_express_control_endpoint(false)
6882            .build()
6883            .expect("invalid params");
6884        let resolver = crate::config::endpoint::DefaultResolver::new();
6885        let endpoint = resolver.resolve_endpoint(&params);
6886        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn");
6887        assert_eq!(
6888            endpoint,
6889            ::aws_smithy_types::endpoint::Endpoint::builder()
6890                .url("https://mybucket--abcd-ab1--x-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn")
6891                .auth_scheme(
6892                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
6893                        .put("disableDoubleEncoding", true)
6894                        .put("signingName", "s3express".to_string())
6895                        .put("signingRegion", "cn-north-1".to_string())
6896                )
6897                .property("backend", "S3Express".to_string())
6898                .build()
6899        );
6900    }
6901
6902    /// Data Plane with short zone name with AP
6903    #[test]
6904    fn test_279() {
6905        let params = crate::config::endpoint::Params::builder()
6906            .region("us-east-1".to_string())
6907            .bucket("myaccesspoint--abcd-ab1--xa-s3".to_string())
6908            .use_fips(false)
6909            .use_dual_stack(false)
6910            .accelerate(false)
6911            .use_s3_express_control_endpoint(false)
6912            .build()
6913            .expect("invalid params");
6914        let resolver = crate::config::endpoint::DefaultResolver::new();
6915        let endpoint = resolver.resolve_endpoint(&params);
6916        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.us-east-1.amazonaws.com");
6917        assert_eq!(
6918            endpoint,
6919            ::aws_smithy_types::endpoint::Endpoint::builder()
6920                .url("https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.us-east-1.amazonaws.com")
6921                .auth_scheme(
6922                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
6923                        .put("disableDoubleEncoding", true)
6924                        .put("signingName", "s3express".to_string())
6925                        .put("signingRegion", "us-east-1".to_string())
6926                )
6927                .property("backend", "S3Express".to_string())
6928                .build()
6929        );
6930    }
6931
6932    /// Data Plane with short zone name with AP china region
6933    #[test]
6934    fn test_280() {
6935        let params = crate::config::endpoint::Params::builder()
6936            .region("cn-north-1".to_string())
6937            .bucket("myaccesspoint--abcd-ab1--xa-s3".to_string())
6938            .use_fips(false)
6939            .use_dual_stack(false)
6940            .accelerate(false)
6941            .use_s3_express_control_endpoint(false)
6942            .build()
6943            .expect("invalid params");
6944        let resolver = crate::config::endpoint::DefaultResolver::new();
6945        let endpoint = resolver.resolve_endpoint(&params);
6946        let endpoint =
6947            endpoint.expect("Expected valid endpoint: https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn");
6948        assert_eq!(
6949            endpoint,
6950            ::aws_smithy_types::endpoint::Endpoint::builder()
6951                .url("https://myaccesspoint--abcd-ab1--xa-s3.s3express-abcd-ab1.cn-north-1.amazonaws.com.cn")
6952                .auth_scheme(
6953                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
6954                        .put("disableDoubleEncoding", true)
6955                        .put("signingName", "s3express".to_string())
6956                        .put("signingRegion", "cn-north-1".to_string())
6957                )
6958                .property("backend", "S3Express".to_string())
6959                .build()
6960        );
6961    }
6962
6963    /// Data Plane with short zone names (13 chars)
6964    #[test]
6965    fn test_281() {
6966        let params = crate::config::endpoint::Params::builder()
6967            .region("us-west-2".to_string())
6968            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
6969            .use_fips(false)
6970            .use_dual_stack(false)
6971            .accelerate(false)
6972            .use_s3_express_control_endpoint(false)
6973            .build()
6974            .expect("invalid params");
6975        let resolver = crate::config::endpoint::DefaultResolver::new();
6976        let endpoint = resolver.resolve_endpoint(&params);
6977        let endpoint =
6978            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
6979        assert_eq!(
6980            endpoint,
6981            ::aws_smithy_types::endpoint::Endpoint::builder()
6982                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
6983                .auth_scheme(
6984                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
6985                        .put("disableDoubleEncoding", true)
6986                        .put("signingName", "s3express".to_string())
6987                        .put("signingRegion", "us-west-2".to_string())
6988                )
6989                .property("backend", "S3Express".to_string())
6990                .build()
6991        );
6992    }
6993
6994    /// Data Plane with short zone names (13 chars) with AP
6995    #[test]
6996    fn test_282() {
6997        let params = crate::config::endpoint::Params::builder()
6998            .region("us-west-2".to_string())
6999            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
7000            .use_fips(false)
7001            .use_dual_stack(false)
7002            .accelerate(false)
7003            .use_s3_express_control_endpoint(false)
7004            .build()
7005            .expect("invalid params");
7006        let resolver = crate::config::endpoint::DefaultResolver::new();
7007        let endpoint = resolver.resolve_endpoint(&params);
7008        let endpoint =
7009            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
7010        assert_eq!(
7011            endpoint,
7012            ::aws_smithy_types::endpoint::Endpoint::builder()
7013                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
7014                .auth_scheme(
7015                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7016                        .put("disableDoubleEncoding", true)
7017                        .put("signingName", "s3express".to_string())
7018                        .put("signingRegion", "us-west-2".to_string())
7019                )
7020                .property("backend", "S3Express".to_string())
7021                .build()
7022        );
7023    }
7024
7025    /// Data Plane with medium zone names (14 chars)
7026    #[test]
7027    fn test_283() {
7028        let params = crate::config::endpoint::Params::builder()
7029            .region("us-west-2".to_string())
7030            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
7031            .use_fips(false)
7032            .use_dual_stack(false)
7033            .accelerate(false)
7034            .use_s3_express_control_endpoint(false)
7035            .build()
7036            .expect("invalid params");
7037        let resolver = crate::config::endpoint::DefaultResolver::new();
7038        let endpoint = resolver.resolve_endpoint(&params);
7039        let endpoint =
7040            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
7041        assert_eq!(
7042            endpoint,
7043            ::aws_smithy_types::endpoint::Endpoint::builder()
7044                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
7045                .auth_scheme(
7046                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7047                        .put("disableDoubleEncoding", true)
7048                        .put("signingName", "s3express".to_string())
7049                        .put("signingRegion", "us-west-2".to_string())
7050                )
7051                .property("backend", "S3Express".to_string())
7052                .build()
7053        );
7054    }
7055
7056    /// Data Plane with medium zone names (14 chars) with AP
7057    #[test]
7058    fn test_284() {
7059        let params = crate::config::endpoint::Params::builder()
7060            .region("us-west-2".to_string())
7061            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
7062            .use_fips(false)
7063            .use_dual_stack(false)
7064            .accelerate(false)
7065            .use_s3_express_control_endpoint(false)
7066            .build()
7067            .expect("invalid params");
7068        let resolver = crate::config::endpoint::DefaultResolver::new();
7069        let endpoint = resolver.resolve_endpoint(&params);
7070        let endpoint =
7071            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
7072        assert_eq!(
7073            endpoint,
7074            ::aws_smithy_types::endpoint::Endpoint::builder()
7075                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
7076                .auth_scheme(
7077                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7078                        .put("disableDoubleEncoding", true)
7079                        .put("signingName", "s3express".to_string())
7080                        .put("signingRegion", "us-west-2".to_string())
7081                )
7082                .property("backend", "S3Express".to_string())
7083                .build()
7084        );
7085    }
7086
7087    /// Data Plane with long zone names (20 chars)
7088    #[test]
7089    fn test_285() {
7090        let params = crate::config::endpoint::Params::builder()
7091            .region("us-west-2".to_string())
7092            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
7093            .use_fips(false)
7094            .use_dual_stack(false)
7095            .accelerate(false)
7096            .use_s3_express_control_endpoint(false)
7097            .build()
7098            .expect("invalid params");
7099        let resolver = crate::config::endpoint::DefaultResolver::new();
7100        let endpoint = resolver.resolve_endpoint(&params);
7101        let endpoint = endpoint
7102            .expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com");
7103        assert_eq!(
7104            endpoint,
7105            ::aws_smithy_types::endpoint::Endpoint::builder()
7106                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
7107                .auth_scheme(
7108                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7109                        .put("disableDoubleEncoding", true)
7110                        .put("signingName", "s3express".to_string())
7111                        .put("signingRegion", "us-west-2".to_string())
7112                )
7113                .property("backend", "S3Express".to_string())
7114                .build()
7115        );
7116    }
7117
7118    /// Data Plane with long zone names (20 chars)
7119    #[test]
7120    fn test_286() {
7121        let params = crate::config::endpoint::Params::builder()
7122            .region("us-west-2".to_string())
7123            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
7124            .use_fips(false)
7125            .use_dual_stack(false)
7126            .accelerate(false)
7127            .use_s3_express_control_endpoint(false)
7128            .build()
7129            .expect("invalid params");
7130        let resolver = crate::config::endpoint::DefaultResolver::new();
7131        let endpoint = resolver.resolve_endpoint(&params);
7132        let endpoint = endpoint.expect(
7133            "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com",
7134        );
7135        assert_eq!(
7136            endpoint,
7137            ::aws_smithy_types::endpoint::Endpoint::builder()
7138                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
7139                .auth_scheme(
7140                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7141                        .put("disableDoubleEncoding", true)
7142                        .put("signingName", "s3express".to_string())
7143                        .put("signingRegion", "us-west-2".to_string())
7144                )
7145                .property("backend", "S3Express".to_string())
7146                .build()
7147        );
7148    }
7149
7150    /// Data Plane with short zone fips
7151    #[test]
7152    fn test_287() {
7153        let params = crate::config::endpoint::Params::builder()
7154            .region("us-east-1".to_string())
7155            .bucket("mybucket--test-ab1--x-s3".to_string())
7156            .use_fips(true)
7157            .use_dual_stack(false)
7158            .accelerate(false)
7159            .use_s3_express_control_endpoint(false)
7160            .build()
7161            .expect("invalid params");
7162        let resolver = crate::config::endpoint::DefaultResolver::new();
7163        let endpoint = resolver.resolve_endpoint(&params);
7164        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test-ab1--x-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com");
7165        assert_eq!(
7166            endpoint,
7167            ::aws_smithy_types::endpoint::Endpoint::builder()
7168                .url("https://mybucket--test-ab1--x-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com")
7169                .auth_scheme(
7170                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7171                        .put("disableDoubleEncoding", true)
7172                        .put("signingName", "s3express".to_string())
7173                        .put("signingRegion", "us-east-1".to_string())
7174                )
7175                .property("backend", "S3Express".to_string())
7176                .build()
7177        );
7178    }
7179
7180    /// Data Plane with short zone fips china region
7181    #[test]
7182    fn test_288() {
7183        let params = crate::config::endpoint::Params::builder()
7184            .region("cn-north-1".to_string())
7185            .bucket("mybucket--test-ab1--x-s3".to_string())
7186            .use_fips(true)
7187            .use_dual_stack(false)
7188            .accelerate(false)
7189            .use_s3_express_control_endpoint(false)
7190            .build()
7191            .expect("invalid params");
7192        let resolver = crate::config::endpoint::DefaultResolver::new();
7193        let endpoint = resolver.resolve_endpoint(&params);
7194        let error = endpoint.expect_err("expected error: Partition does not support FIPS [Data Plane with short zone fips china region]");
7195        assert_eq!(format!("{}", error), "Partition does not support FIPS")
7196    }
7197
7198    /// Data Plane with short zone fips with AP
7199    #[test]
7200    fn test_289() {
7201        let params = crate::config::endpoint::Params::builder()
7202            .region("us-east-1".to_string())
7203            .bucket("myaccesspoint--test-ab1--xa-s3".to_string())
7204            .use_fips(true)
7205            .use_dual_stack(false)
7206            .accelerate(false)
7207            .use_s3_express_control_endpoint(false)
7208            .build()
7209            .expect("invalid params");
7210        let resolver = crate::config::endpoint::DefaultResolver::new();
7211        let endpoint = resolver.resolve_endpoint(&params);
7212        let endpoint =
7213            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test-ab1--xa-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com");
7214        assert_eq!(
7215            endpoint,
7216            ::aws_smithy_types::endpoint::Endpoint::builder()
7217                .url("https://myaccesspoint--test-ab1--xa-s3.s3express-fips-test-ab1.us-east-1.amazonaws.com")
7218                .auth_scheme(
7219                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7220                        .put("disableDoubleEncoding", true)
7221                        .put("signingName", "s3express".to_string())
7222                        .put("signingRegion", "us-east-1".to_string())
7223                )
7224                .property("backend", "S3Express".to_string())
7225                .build()
7226        );
7227    }
7228
7229    /// Data Plane with short zone fips with AP china region
7230    #[test]
7231    fn test_290() {
7232        let params = crate::config::endpoint::Params::builder()
7233            .region("cn-north-1".to_string())
7234            .bucket("myaccesspoint--test-ab1--xa-s3".to_string())
7235            .use_fips(true)
7236            .use_dual_stack(false)
7237            .accelerate(false)
7238            .use_s3_express_control_endpoint(false)
7239            .build()
7240            .expect("invalid params");
7241        let resolver = crate::config::endpoint::DefaultResolver::new();
7242        let endpoint = resolver.resolve_endpoint(&params);
7243        let error = endpoint.expect_err("expected error: Partition does not support FIPS [Data Plane with short zone fips with AP china region]");
7244        assert_eq!(format!("{}", error), "Partition does not support FIPS")
7245    }
7246
7247    /// Data Plane with short zone (13 chars) fips
7248    #[test]
7249    fn test_291() {
7250        let params = crate::config::endpoint::Params::builder()
7251            .region("us-west-2".to_string())
7252            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
7253            .use_fips(true)
7254            .use_dual_stack(false)
7255            .accelerate(false)
7256            .use_s3_express_control_endpoint(false)
7257            .build()
7258            .expect("invalid params");
7259        let resolver = crate::config::endpoint::DefaultResolver::new();
7260        let endpoint = resolver.resolve_endpoint(&params);
7261        let endpoint =
7262            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
7263        assert_eq!(
7264            endpoint,
7265            ::aws_smithy_types::endpoint::Endpoint::builder()
7266                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
7267                .auth_scheme(
7268                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7269                        .put("disableDoubleEncoding", true)
7270                        .put("signingName", "s3express".to_string())
7271                        .put("signingRegion", "us-west-2".to_string())
7272                )
7273                .property("backend", "S3Express".to_string())
7274                .build()
7275        );
7276    }
7277
7278    /// Data Plane with short zone (13 chars) fips with AP
7279    #[test]
7280    fn test_292() {
7281        let params = crate::config::endpoint::Params::builder()
7282            .region("us-west-2".to_string())
7283            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
7284            .use_fips(true)
7285            .use_dual_stack(false)
7286            .accelerate(false)
7287            .use_s3_express_control_endpoint(false)
7288            .build()
7289            .expect("invalid params");
7290        let resolver = crate::config::endpoint::DefaultResolver::new();
7291        let endpoint = resolver.resolve_endpoint(&params);
7292        let endpoint = endpoint
7293            .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
7294        assert_eq!(
7295            endpoint,
7296            ::aws_smithy_types::endpoint::Endpoint::builder()
7297                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
7298                .auth_scheme(
7299                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7300                        .put("disableDoubleEncoding", true)
7301                        .put("signingName", "s3express".to_string())
7302                        .put("signingRegion", "us-west-2".to_string())
7303                )
7304                .property("backend", "S3Express".to_string())
7305                .build()
7306        );
7307    }
7308
7309    /// Data Plane with medium zone (14 chars) fips
7310    #[test]
7311    fn test_293() {
7312        let params = crate::config::endpoint::Params::builder()
7313            .region("us-west-2".to_string())
7314            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
7315            .use_fips(true)
7316            .use_dual_stack(false)
7317            .accelerate(false)
7318            .use_s3_express_control_endpoint(false)
7319            .build()
7320            .expect("invalid params");
7321        let resolver = crate::config::endpoint::DefaultResolver::new();
7322        let endpoint = resolver.resolve_endpoint(&params);
7323        let endpoint =
7324            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
7325        assert_eq!(
7326            endpoint,
7327            ::aws_smithy_types::endpoint::Endpoint::builder()
7328                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
7329                .auth_scheme(
7330                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7331                        .put("disableDoubleEncoding", true)
7332                        .put("signingName", "s3express".to_string())
7333                        .put("signingRegion", "us-west-2".to_string())
7334                )
7335                .property("backend", "S3Express".to_string())
7336                .build()
7337        );
7338    }
7339
7340    /// Data Plane with medium zone (14 chars) fips with AP
7341    #[test]
7342    fn test_294() {
7343        let params = crate::config::endpoint::Params::builder()
7344            .region("us-west-2".to_string())
7345            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
7346            .use_fips(true)
7347            .use_dual_stack(false)
7348            .accelerate(false)
7349            .use_s3_express_control_endpoint(false)
7350            .build()
7351            .expect("invalid params");
7352        let resolver = crate::config::endpoint::DefaultResolver::new();
7353        let endpoint = resolver.resolve_endpoint(&params);
7354        let endpoint = endpoint
7355            .expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
7356        assert_eq!(
7357            endpoint,
7358            ::aws_smithy_types::endpoint::Endpoint::builder()
7359                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
7360                .auth_scheme(
7361                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7362                        .put("disableDoubleEncoding", true)
7363                        .put("signingName", "s3express".to_string())
7364                        .put("signingRegion", "us-west-2".to_string())
7365                )
7366                .property("backend", "S3Express".to_string())
7367                .build()
7368        );
7369    }
7370
7371    /// Data Plane with long zone (20 chars) fips
7372    #[test]
7373    fn test_295() {
7374        let params = crate::config::endpoint::Params::builder()
7375            .region("us-west-2".to_string())
7376            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
7377            .use_fips(true)
7378            .use_dual_stack(false)
7379            .accelerate(false)
7380            .use_s3_express_control_endpoint(false)
7381            .build()
7382            .expect("invalid params");
7383        let resolver = crate::config::endpoint::DefaultResolver::new();
7384        let endpoint = resolver.resolve_endpoint(&params);
7385        let endpoint = endpoint.expect(
7386            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
7387        );
7388        assert_eq!(
7389            endpoint,
7390            ::aws_smithy_types::endpoint::Endpoint::builder()
7391                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
7392                .auth_scheme(
7393                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7394                        .put("disableDoubleEncoding", true)
7395                        .put("signingName", "s3express".to_string())
7396                        .put("signingRegion", "us-west-2".to_string())
7397                )
7398                .property("backend", "S3Express".to_string())
7399                .build()
7400        );
7401    }
7402
7403    /// Data Plane with long zone (20 chars) fips with AP
7404    #[test]
7405    fn test_296() {
7406        let params = crate::config::endpoint::Params::builder()
7407            .region("us-west-2".to_string())
7408            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
7409            .use_fips(true)
7410            .use_dual_stack(false)
7411            .accelerate(false)
7412            .use_s3_express_control_endpoint(false)
7413            .build()
7414            .expect("invalid params");
7415        let resolver = crate::config::endpoint::DefaultResolver::new();
7416        let endpoint = resolver.resolve_endpoint(&params);
7417        let endpoint = endpoint.expect(
7418            "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
7419        );
7420        assert_eq!(
7421            endpoint,
7422            ::aws_smithy_types::endpoint::Endpoint::builder()
7423                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
7424                .auth_scheme(
7425                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7426                        .put("disableDoubleEncoding", true)
7427                        .put("signingName", "s3express".to_string())
7428                        .put("signingRegion", "us-west-2".to_string())
7429                )
7430                .property("backend", "S3Express".to_string())
7431                .build()
7432        );
7433    }
7434
7435    /// Data Plane with long AZ
7436    #[test]
7437    fn test_297() {
7438        let params = crate::config::endpoint::Params::builder()
7439            .region("us-west-2".to_string())
7440            .bucket("mybucket--test1-az1--x-s3".to_string())
7441            .use_fips(false)
7442            .use_dual_stack(false)
7443            .accelerate(false)
7444            .use_s3_express_control_endpoint(false)
7445            .build()
7446            .expect("invalid params");
7447        let resolver = crate::config::endpoint::DefaultResolver::new();
7448        let endpoint = resolver.resolve_endpoint(&params);
7449        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com");
7450        assert_eq!(
7451            endpoint,
7452            ::aws_smithy_types::endpoint::Endpoint::builder()
7453                .url("https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com")
7454                .auth_scheme(
7455                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7456                        .put("disableDoubleEncoding", true)
7457                        .put("signingName", "s3express".to_string())
7458                        .put("signingRegion", "us-west-2".to_string())
7459                )
7460                .property("backend", "S3Express".to_string())
7461                .build()
7462        );
7463    }
7464
7465    /// Data Plane with long AZ with AP
7466    #[test]
7467    fn test_298() {
7468        let params = crate::config::endpoint::Params::builder()
7469            .region("us-west-2".to_string())
7470            .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
7471            .use_fips(false)
7472            .use_dual_stack(false)
7473            .accelerate(false)
7474            .use_s3_express_control_endpoint(false)
7475            .build()
7476            .expect("invalid params");
7477        let resolver = crate::config::endpoint::DefaultResolver::new();
7478        let endpoint = resolver.resolve_endpoint(&params);
7479        let endpoint =
7480            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com");
7481        assert_eq!(
7482            endpoint,
7483            ::aws_smithy_types::endpoint::Endpoint::builder()
7484                .url("https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com")
7485                .auth_scheme(
7486                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7487                        .put("disableDoubleEncoding", true)
7488                        .put("signingName", "s3express".to_string())
7489                        .put("signingRegion", "us-west-2".to_string())
7490                )
7491                .property("backend", "S3Express".to_string())
7492                .build()
7493        );
7494    }
7495
7496    /// Data Plane with long AZ fips
7497    #[test]
7498    fn test_299() {
7499        let params = crate::config::endpoint::Params::builder()
7500            .region("us-west-2".to_string())
7501            .bucket("mybucket--test1-az1--x-s3".to_string())
7502            .use_fips(true)
7503            .use_dual_stack(false)
7504            .accelerate(false)
7505            .use_s3_express_control_endpoint(false)
7506            .build()
7507            .expect("invalid params");
7508        let resolver = crate::config::endpoint::DefaultResolver::new();
7509        let endpoint = resolver.resolve_endpoint(&params);
7510        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
7511        assert_eq!(
7512            endpoint,
7513            ::aws_smithy_types::endpoint::Endpoint::builder()
7514                .url("https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
7515                .auth_scheme(
7516                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7517                        .put("disableDoubleEncoding", true)
7518                        .put("signingName", "s3express".to_string())
7519                        .put("signingRegion", "us-west-2".to_string())
7520                )
7521                .property("backend", "S3Express".to_string())
7522                .build()
7523        );
7524    }
7525
7526    /// Data Plane with long AZ fips with AP
7527    #[test]
7528    fn test_300() {
7529        let params = crate::config::endpoint::Params::builder()
7530            .region("us-west-2".to_string())
7531            .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
7532            .use_fips(true)
7533            .use_dual_stack(false)
7534            .accelerate(false)
7535            .use_s3_express_control_endpoint(false)
7536            .build()
7537            .expect("invalid params");
7538        let resolver = crate::config::endpoint::DefaultResolver::new();
7539        let endpoint = resolver.resolve_endpoint(&params);
7540        let endpoint =
7541            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
7542        assert_eq!(
7543            endpoint,
7544            ::aws_smithy_types::endpoint::Endpoint::builder()
7545                .url("https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
7546                .auth_scheme(
7547                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
7548                        .put("disableDoubleEncoding", true)
7549                        .put("signingName", "s3express".to_string())
7550                        .put("signingRegion", "us-west-2".to_string())
7551                )
7552                .property("backend", "S3Express".to_string())
7553                .build()
7554        );
7555    }
7556
7557    /// Control plane with short AZ bucket
7558    #[test]
7559    fn test_301() {
7560        let params = crate::config::endpoint::Params::builder()
7561            .region("us-east-1".to_string())
7562            .bucket("mybucket--test-ab1--x-s3".to_string())
7563            .use_fips(false)
7564            .use_dual_stack(false)
7565            .accelerate(false)
7566            .use_s3_express_control_endpoint(true)
7567            .disable_s3_express_session_auth(false)
7568            .build()
7569            .expect("invalid params");
7570        let resolver = crate::config::endpoint::DefaultResolver::new();
7571        let endpoint = resolver.resolve_endpoint(&params);
7572        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
7573        assert_eq!(
7574            endpoint,
7575            ::aws_smithy_types::endpoint::Endpoint::builder()
7576                .url("https://s3express-control.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
7577                .auth_scheme(
7578                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
7579                        .put("disableDoubleEncoding", true)
7580                        .put("signingName", "s3express".to_string())
7581                        .put("signingRegion", "us-east-1".to_string())
7582                )
7583                .property("backend", "S3Express".to_string())
7584                .build()
7585        );
7586    }
7587
7588    /// Control plane with short AZ bucket china region
7589    #[test]
7590    fn test_302() {
7591        let params = crate::config::endpoint::Params::builder()
7592            .region("cn-north-1".to_string())
7593            .bucket("mybucket--test-ab1--x-s3".to_string())
7594            .use_fips(false)
7595            .use_dual_stack(false)
7596            .accelerate(false)
7597            .use_s3_express_control_endpoint(true)
7598            .disable_s3_express_session_auth(false)
7599            .build()
7600            .expect("invalid params");
7601        let resolver = crate::config::endpoint::DefaultResolver::new();
7602        let endpoint = resolver.resolve_endpoint(&params);
7603        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.cn-north-1.amazonaws.com.cn/mybucket--test-ab1--x-s3");
7604        assert_eq!(
7605            endpoint,
7606            ::aws_smithy_types::endpoint::Endpoint::builder()
7607                .url("https://s3express-control.cn-north-1.amazonaws.com.cn/mybucket--test-ab1--x-s3")
7608                .auth_scheme(
7609                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
7610                        .put("disableDoubleEncoding", true)
7611                        .put("signingName", "s3express".to_string())
7612                        .put("signingRegion", "cn-north-1".to_string())
7613                )
7614                .property("backend", "S3Express".to_string())
7615                .build()
7616        );
7617    }
7618
7619    /// Control plane with short AZ bucket and fips
7620    #[test]
7621    fn test_303() {
7622        let params = crate::config::endpoint::Params::builder()
7623            .region("us-east-1".to_string())
7624            .bucket("mybucket--test-ab1--x-s3".to_string())
7625            .use_fips(true)
7626            .use_dual_stack(false)
7627            .accelerate(false)
7628            .use_s3_express_control_endpoint(true)
7629            .disable_s3_express_session_auth(false)
7630            .build()
7631            .expect("invalid params");
7632        let resolver = crate::config::endpoint::DefaultResolver::new();
7633        let endpoint = resolver.resolve_endpoint(&params);
7634        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
7635        assert_eq!(
7636            endpoint,
7637            ::aws_smithy_types::endpoint::Endpoint::builder()
7638                .url("https://s3express-control-fips.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
7639                .auth_scheme(
7640                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
7641                        .put("disableDoubleEncoding", true)
7642                        .put("signingName", "s3express".to_string())
7643                        .put("signingRegion", "us-east-1".to_string())
7644                )
7645                .property("backend", "S3Express".to_string())
7646                .build()
7647        );
7648    }
7649
7650    /// Control plane with short AZ bucket and fips china region
7651    #[test]
7652    fn test_304() {
7653        let params = crate::config::endpoint::Params::builder()
7654            .region("cn-north-1".to_string())
7655            .bucket("mybucket--test-ab1--x-s3".to_string())
7656            .use_fips(true)
7657            .use_dual_stack(false)
7658            .accelerate(false)
7659            .use_s3_express_control_endpoint(true)
7660            .disable_s3_express_session_auth(false)
7661            .build()
7662            .expect("invalid params");
7663        let resolver = crate::config::endpoint::DefaultResolver::new();
7664        let endpoint = resolver.resolve_endpoint(&params);
7665        let error = endpoint.expect_err("expected error: Partition does not support FIPS [Control plane with short AZ bucket and fips china region]");
7666        assert_eq!(format!("{}", error), "Partition does not support FIPS")
7667    }
7668
7669    /// Control plane without bucket
7670    #[test]
7671    fn test_305() {
7672        let params = crate::config::endpoint::Params::builder()
7673            .region("us-east-1".to_string())
7674            .use_fips(false)
7675            .use_dual_stack(false)
7676            .accelerate(false)
7677            .use_s3_express_control_endpoint(true)
7678            .disable_s3_express_session_auth(false)
7679            .build()
7680            .expect("invalid params");
7681        let resolver = crate::config::endpoint::DefaultResolver::new();
7682        let endpoint = resolver.resolve_endpoint(&params);
7683        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com");
7684        assert_eq!(
7685            endpoint,
7686            ::aws_smithy_types::endpoint::Endpoint::builder()
7687                .url("https://s3express-control.us-east-1.amazonaws.com")
7688                .auth_scheme(
7689                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
7690                        .put("disableDoubleEncoding", true)
7691                        .put("signingName", "s3express".to_string())
7692                        .put("signingRegion", "us-east-1".to_string())
7693                )
7694                .property("backend", "S3Express".to_string())
7695                .build()
7696        );
7697    }
7698
7699    /// Control plane without bucket and fips
7700    #[test]
7701    fn test_306() {
7702        let params = crate::config::endpoint::Params::builder()
7703            .region("us-east-1".to_string())
7704            .use_fips(true)
7705            .use_dual_stack(false)
7706            .accelerate(false)
7707            .use_s3_express_control_endpoint(true)
7708            .disable_s3_express_session_auth(false)
7709            .build()
7710            .expect("invalid params");
7711        let resolver = crate::config::endpoint::DefaultResolver::new();
7712        let endpoint = resolver.resolve_endpoint(&params);
7713        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.us-east-1.amazonaws.com");
7714        assert_eq!(
7715            endpoint,
7716            ::aws_smithy_types::endpoint::Endpoint::builder()
7717                .url("https://s3express-control-fips.us-east-1.amazonaws.com")
7718                .auth_scheme(
7719                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
7720                        .put("disableDoubleEncoding", true)
7721                        .put("signingName", "s3express".to_string())
7722                        .put("signingRegion", "us-east-1".to_string())
7723                )
7724                .property("backend", "S3Express".to_string())
7725                .build()
7726        );
7727    }
7728
7729    /// Data Plane sigv4 auth with short AZ
7730    #[test]
7731    fn test_307() {
7732        let params = crate::config::endpoint::Params::builder()
7733            .region("us-west-2".to_string())
7734            .bucket("mybucket--usw2-az1--x-s3".to_string())
7735            .use_fips(false)
7736            .use_dual_stack(false)
7737            .accelerate(false)
7738            .disable_s3_express_session_auth(true)
7739            .build()
7740            .expect("invalid params");
7741        let resolver = crate::config::endpoint::DefaultResolver::new();
7742        let endpoint = resolver.resolve_endpoint(&params);
7743        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com");
7744        assert_eq!(
7745            endpoint,
7746            ::aws_smithy_types::endpoint::Endpoint::builder()
7747                .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.us-west-2.amazonaws.com")
7748                .auth_scheme(
7749                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
7750                        .put("disableDoubleEncoding", true)
7751                        .put("signingName", "s3express".to_string())
7752                        .put("signingRegion", "us-west-2".to_string())
7753                )
7754                .property("backend", "S3Express".to_string())
7755                .build()
7756        );
7757    }
7758
7759    /// Data Plane sigv4 auth with short AZ with AP
7760    #[test]
7761    fn test_308() {
7762        let params = crate::config::endpoint::Params::builder()
7763            .region("us-west-2".to_string())
7764            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
7765            .use_fips(false)
7766            .use_dual_stack(false)
7767            .accelerate(false)
7768            .disable_s3_express_session_auth(true)
7769            .build()
7770            .expect("invalid params");
7771        let resolver = crate::config::endpoint::DefaultResolver::new();
7772        let endpoint = resolver.resolve_endpoint(&params);
7773        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.us-west-2.amazonaws.com");
7774        assert_eq!(
7775            endpoint,
7776            ::aws_smithy_types::endpoint::Endpoint::builder()
7777                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.us-west-2.amazonaws.com")
7778                .auth_scheme(
7779                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
7780                        .put("disableDoubleEncoding", true)
7781                        .put("signingName", "s3express".to_string())
7782                        .put("signingRegion", "us-west-2".to_string())
7783                )
7784                .property("backend", "S3Express".to_string())
7785                .build()
7786        );
7787    }
7788
7789    /// Data Plane sigv4 auth with short zone (13 chars)
7790    #[test]
7791    fn test_309() {
7792        let params = crate::config::endpoint::Params::builder()
7793            .region("us-west-2".to_string())
7794            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
7795            .use_fips(false)
7796            .use_dual_stack(false)
7797            .accelerate(false)
7798            .disable_s3_express_session_auth(true)
7799            .build()
7800            .expect("invalid params");
7801        let resolver = crate::config::endpoint::DefaultResolver::new();
7802        let endpoint = resolver.resolve_endpoint(&params);
7803        let endpoint =
7804            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
7805        assert_eq!(
7806            endpoint,
7807            ::aws_smithy_types::endpoint::Endpoint::builder()
7808                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
7809                .auth_scheme(
7810                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
7811                        .put("disableDoubleEncoding", true)
7812                        .put("signingName", "s3express".to_string())
7813                        .put("signingRegion", "us-west-2".to_string())
7814                )
7815                .property("backend", "S3Express".to_string())
7816                .build()
7817        );
7818    }
7819
7820    /// Data Plane sigv4 auth with short zone (13 chars) with AP
7821    #[test]
7822    fn test_310() {
7823        let params = crate::config::endpoint::Params::builder()
7824            .region("us-west-2".to_string())
7825            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
7826            .use_fips(false)
7827            .use_dual_stack(false)
7828            .accelerate(false)
7829            .disable_s3_express_session_auth(true)
7830            .build()
7831            .expect("invalid params");
7832        let resolver = crate::config::endpoint::DefaultResolver::new();
7833        let endpoint = resolver.resolve_endpoint(&params);
7834        let endpoint =
7835            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com");
7836        assert_eq!(
7837            endpoint,
7838            ::aws_smithy_types::endpoint::Endpoint::builder()
7839                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.us-west-2.amazonaws.com")
7840                .auth_scheme(
7841                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
7842                        .put("disableDoubleEncoding", true)
7843                        .put("signingName", "s3express".to_string())
7844                        .put("signingRegion", "us-west-2".to_string())
7845                )
7846                .property("backend", "S3Express".to_string())
7847                .build()
7848        );
7849    }
7850
7851    /// Data Plane sigv4 auth with short AZ fips
7852    #[test]
7853    fn test_311() {
7854        let params = crate::config::endpoint::Params::builder()
7855            .region("us-west-2".to_string())
7856            .bucket("mybucket--usw2-az1--x-s3".to_string())
7857            .use_fips(true)
7858            .use_dual_stack(false)
7859            .accelerate(false)
7860            .disable_s3_express_session_auth(true)
7861            .build()
7862            .expect("invalid params");
7863        let resolver = crate::config::endpoint::DefaultResolver::new();
7864        let endpoint = resolver.resolve_endpoint(&params);
7865        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com");
7866        assert_eq!(
7867            endpoint,
7868            ::aws_smithy_types::endpoint::Endpoint::builder()
7869                .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com")
7870                .auth_scheme(
7871                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
7872                        .put("disableDoubleEncoding", true)
7873                        .put("signingName", "s3express".to_string())
7874                        .put("signingRegion", "us-west-2".to_string())
7875                )
7876                .property("backend", "S3Express".to_string())
7877                .build()
7878        );
7879    }
7880
7881    /// Data Plane sigv4 auth with short AZ fips with AP
7882    #[test]
7883    fn test_312() {
7884        let params = crate::config::endpoint::Params::builder()
7885            .region("us-west-2".to_string())
7886            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
7887            .use_fips(true)
7888            .use_dual_stack(false)
7889            .accelerate(false)
7890            .disable_s3_express_session_auth(true)
7891            .build()
7892            .expect("invalid params");
7893        let resolver = crate::config::endpoint::DefaultResolver::new();
7894        let endpoint = resolver.resolve_endpoint(&params);
7895        let endpoint =
7896            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com");
7897        assert_eq!(
7898            endpoint,
7899            ::aws_smithy_types::endpoint::Endpoint::builder()
7900                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.us-west-2.amazonaws.com")
7901                .auth_scheme(
7902                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
7903                        .put("disableDoubleEncoding", true)
7904                        .put("signingName", "s3express".to_string())
7905                        .put("signingRegion", "us-west-2".to_string())
7906                )
7907                .property("backend", "S3Express".to_string())
7908                .build()
7909        );
7910    }
7911
7912    /// Data Plane sigv4 auth with short zone (13 chars) fips
7913    #[test]
7914    fn test_313() {
7915        let params = crate::config::endpoint::Params::builder()
7916            .region("us-west-2".to_string())
7917            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
7918            .use_fips(true)
7919            .use_dual_stack(false)
7920            .accelerate(false)
7921            .disable_s3_express_session_auth(true)
7922            .build()
7923            .expect("invalid params");
7924        let resolver = crate::config::endpoint::DefaultResolver::new();
7925        let endpoint = resolver.resolve_endpoint(&params);
7926        let endpoint =
7927            endpoint.expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
7928        assert_eq!(
7929            endpoint,
7930            ::aws_smithy_types::endpoint::Endpoint::builder()
7931                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
7932                .auth_scheme(
7933                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
7934                        .put("disableDoubleEncoding", true)
7935                        .put("signingName", "s3express".to_string())
7936                        .put("signingRegion", "us-west-2".to_string())
7937                )
7938                .property("backend", "S3Express".to_string())
7939                .build()
7940        );
7941    }
7942
7943    /// Data Plane sigv4 auth with short zone (13 chars) fips with AP
7944    #[test]
7945    fn test_314() {
7946        let params = crate::config::endpoint::Params::builder()
7947            .region("us-west-2".to_string())
7948            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
7949            .use_fips(true)
7950            .use_dual_stack(false)
7951            .accelerate(false)
7952            .disable_s3_express_session_auth(true)
7953            .build()
7954            .expect("invalid params");
7955        let resolver = crate::config::endpoint::DefaultResolver::new();
7956        let endpoint = resolver.resolve_endpoint(&params);
7957        let endpoint = endpoint
7958            .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com");
7959        assert_eq!(
7960            endpoint,
7961            ::aws_smithy_types::endpoint::Endpoint::builder()
7962                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.us-west-2.amazonaws.com")
7963                .auth_scheme(
7964                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
7965                        .put("disableDoubleEncoding", true)
7966                        .put("signingName", "s3express".to_string())
7967                        .put("signingRegion", "us-west-2".to_string())
7968                )
7969                .property("backend", "S3Express".to_string())
7970                .build()
7971        );
7972    }
7973
7974    /// Data Plane sigv4 auth with long AZ
7975    #[test]
7976    fn test_315() {
7977        let params = crate::config::endpoint::Params::builder()
7978            .region("us-west-2".to_string())
7979            .bucket("mybucket--test1-az1--x-s3".to_string())
7980            .use_fips(false)
7981            .use_dual_stack(false)
7982            .accelerate(false)
7983            .use_s3_express_control_endpoint(false)
7984            .disable_s3_express_session_auth(true)
7985            .build()
7986            .expect("invalid params");
7987        let resolver = crate::config::endpoint::DefaultResolver::new();
7988        let endpoint = resolver.resolve_endpoint(&params);
7989        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com");
7990        assert_eq!(
7991            endpoint,
7992            ::aws_smithy_types::endpoint::Endpoint::builder()
7993                .url("https://mybucket--test1-az1--x-s3.s3express-test1-az1.us-west-2.amazonaws.com")
7994                .auth_scheme(
7995                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
7996                        .put("disableDoubleEncoding", true)
7997                        .put("signingName", "s3express".to_string())
7998                        .put("signingRegion", "us-west-2".to_string())
7999                )
8000                .property("backend", "S3Express".to_string())
8001                .build()
8002        );
8003    }
8004
8005    /// Data Plane sigv4 auth with long AZ with AP
8006    #[test]
8007    fn test_316() {
8008        let params = crate::config::endpoint::Params::builder()
8009            .region("us-west-2".to_string())
8010            .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
8011            .use_fips(false)
8012            .use_dual_stack(false)
8013            .accelerate(false)
8014            .use_s3_express_control_endpoint(false)
8015            .disable_s3_express_session_auth(true)
8016            .build()
8017            .expect("invalid params");
8018        let resolver = crate::config::endpoint::DefaultResolver::new();
8019        let endpoint = resolver.resolve_endpoint(&params);
8020        let endpoint =
8021            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com");
8022        assert_eq!(
8023            endpoint,
8024            ::aws_smithy_types::endpoint::Endpoint::builder()
8025                .url("https://myaccesspoint--test1-az1--xa-s3.s3express-test1-az1.us-west-2.amazonaws.com")
8026                .auth_scheme(
8027                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8028                        .put("disableDoubleEncoding", true)
8029                        .put("signingName", "s3express".to_string())
8030                        .put("signingRegion", "us-west-2".to_string())
8031                )
8032                .property("backend", "S3Express".to_string())
8033                .build()
8034        );
8035    }
8036
8037    /// Data Plane sigv4 auth with medium zone(14 chars)
8038    #[test]
8039    fn test_317() {
8040        let params = crate::config::endpoint::Params::builder()
8041            .region("us-west-2".to_string())
8042            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
8043            .use_fips(false)
8044            .use_dual_stack(false)
8045            .accelerate(false)
8046            .use_s3_express_control_endpoint(false)
8047            .disable_s3_express_session_auth(true)
8048            .build()
8049            .expect("invalid params");
8050        let resolver = crate::config::endpoint::DefaultResolver::new();
8051        let endpoint = resolver.resolve_endpoint(&params);
8052        let endpoint =
8053            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
8054        assert_eq!(
8055            endpoint,
8056            ::aws_smithy_types::endpoint::Endpoint::builder()
8057                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
8058                .auth_scheme(
8059                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8060                        .put("disableDoubleEncoding", true)
8061                        .put("signingName", "s3express".to_string())
8062                        .put("signingRegion", "us-west-2".to_string())
8063                )
8064                .property("backend", "S3Express".to_string())
8065                .build()
8066        );
8067    }
8068
8069    /// Data Plane sigv4 auth with medium zone(14 chars) with AP
8070    #[test]
8071    fn test_318() {
8072        let params = crate::config::endpoint::Params::builder()
8073            .region("us-west-2".to_string())
8074            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
8075            .use_fips(false)
8076            .use_dual_stack(false)
8077            .accelerate(false)
8078            .use_s3_express_control_endpoint(false)
8079            .disable_s3_express_session_auth(true)
8080            .build()
8081            .expect("invalid params");
8082        let resolver = crate::config::endpoint::DefaultResolver::new();
8083        let endpoint = resolver.resolve_endpoint(&params);
8084        let endpoint =
8085            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com");
8086        assert_eq!(
8087            endpoint,
8088            ::aws_smithy_types::endpoint::Endpoint::builder()
8089                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.us-west-2.amazonaws.com")
8090                .auth_scheme(
8091                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8092                        .put("disableDoubleEncoding", true)
8093                        .put("signingName", "s3express".to_string())
8094                        .put("signingRegion", "us-west-2".to_string())
8095                )
8096                .property("backend", "S3Express".to_string())
8097                .build()
8098        );
8099    }
8100
8101    /// Data Plane sigv4 auth with long zone(20 chars)
8102    #[test]
8103    fn test_319() {
8104        let params = crate::config::endpoint::Params::builder()
8105            .region("us-west-2".to_string())
8106            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
8107            .use_fips(false)
8108            .use_dual_stack(false)
8109            .accelerate(false)
8110            .use_s3_express_control_endpoint(false)
8111            .disable_s3_express_session_auth(true)
8112            .build()
8113            .expect("invalid params");
8114        let resolver = crate::config::endpoint::DefaultResolver::new();
8115        let endpoint = resolver.resolve_endpoint(&params);
8116        let endpoint = endpoint
8117            .expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com");
8118        assert_eq!(
8119            endpoint,
8120            ::aws_smithy_types::endpoint::Endpoint::builder()
8121                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
8122                .auth_scheme(
8123                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8124                        .put("disableDoubleEncoding", true)
8125                        .put("signingName", "s3express".to_string())
8126                        .put("signingRegion", "us-west-2".to_string())
8127                )
8128                .property("backend", "S3Express".to_string())
8129                .build()
8130        );
8131    }
8132
8133    /// Data Plane sigv4 auth with long zone(20 chars) with AP
8134    #[test]
8135    fn test_320() {
8136        let params = crate::config::endpoint::Params::builder()
8137            .region("us-west-2".to_string())
8138            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
8139            .use_fips(false)
8140            .use_dual_stack(false)
8141            .accelerate(false)
8142            .use_s3_express_control_endpoint(false)
8143            .disable_s3_express_session_auth(true)
8144            .build()
8145            .expect("invalid params");
8146        let resolver = crate::config::endpoint::DefaultResolver::new();
8147        let endpoint = resolver.resolve_endpoint(&params);
8148        let endpoint = endpoint.expect(
8149            "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com",
8150        );
8151        assert_eq!(
8152            endpoint,
8153            ::aws_smithy_types::endpoint::Endpoint::builder()
8154                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.us-west-2.amazonaws.com")
8155                .auth_scheme(
8156                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8157                        .put("disableDoubleEncoding", true)
8158                        .put("signingName", "s3express".to_string())
8159                        .put("signingRegion", "us-west-2".to_string())
8160                )
8161                .property("backend", "S3Express".to_string())
8162                .build()
8163        );
8164    }
8165
8166    /// Data Plane sigv4 auth with long AZ fips
8167    #[test]
8168    fn test_321() {
8169        let params = crate::config::endpoint::Params::builder()
8170            .region("us-west-2".to_string())
8171            .bucket("mybucket--test1-az1--x-s3".to_string())
8172            .use_fips(true)
8173            .use_dual_stack(false)
8174            .accelerate(false)
8175            .use_s3_express_control_endpoint(false)
8176            .disable_s3_express_session_auth(true)
8177            .build()
8178            .expect("invalid params");
8179        let resolver = crate::config::endpoint::DefaultResolver::new();
8180        let endpoint = resolver.resolve_endpoint(&params);
8181        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
8182        assert_eq!(
8183            endpoint,
8184            ::aws_smithy_types::endpoint::Endpoint::builder()
8185                .url("https://mybucket--test1-az1--x-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
8186                .auth_scheme(
8187                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8188                        .put("disableDoubleEncoding", true)
8189                        .put("signingName", "s3express".to_string())
8190                        .put("signingRegion", "us-west-2".to_string())
8191                )
8192                .property("backend", "S3Express".to_string())
8193                .build()
8194        );
8195    }
8196
8197    /// Data Plane sigv4 auth with long AZ fips with AP
8198    #[test]
8199    fn test_322() {
8200        let params = crate::config::endpoint::Params::builder()
8201            .region("us-west-2".to_string())
8202            .bucket("myaccesspoint--test1-az1--xa-s3".to_string())
8203            .use_fips(true)
8204            .use_dual_stack(false)
8205            .accelerate(false)
8206            .use_s3_express_control_endpoint(false)
8207            .disable_s3_express_session_auth(true)
8208            .build()
8209            .expect("invalid params");
8210        let resolver = crate::config::endpoint::DefaultResolver::new();
8211        let endpoint = resolver.resolve_endpoint(&params);
8212        let endpoint =
8213            endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com");
8214        assert_eq!(
8215            endpoint,
8216            ::aws_smithy_types::endpoint::Endpoint::builder()
8217                .url("https://myaccesspoint--test1-az1--xa-s3.s3express-fips-test1-az1.us-west-2.amazonaws.com")
8218                .auth_scheme(
8219                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8220                        .put("disableDoubleEncoding", true)
8221                        .put("signingName", "s3express".to_string())
8222                        .put("signingRegion", "us-west-2".to_string())
8223                )
8224                .property("backend", "S3Express".to_string())
8225                .build()
8226        );
8227    }
8228
8229    /// Data Plane sigv4 auth with medium zone (14 chars) fips
8230    #[test]
8231    fn test_323() {
8232        let params = crate::config::endpoint::Params::builder()
8233            .region("us-west-2".to_string())
8234            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
8235            .use_fips(true)
8236            .use_dual_stack(false)
8237            .accelerate(false)
8238            .use_s3_express_control_endpoint(false)
8239            .disable_s3_express_session_auth(true)
8240            .build()
8241            .expect("invalid params");
8242        let resolver = crate::config::endpoint::DefaultResolver::new();
8243        let endpoint = resolver.resolve_endpoint(&params);
8244        let endpoint =
8245            endpoint.expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
8246        assert_eq!(
8247            endpoint,
8248            ::aws_smithy_types::endpoint::Endpoint::builder()
8249                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
8250                .auth_scheme(
8251                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8252                        .put("disableDoubleEncoding", true)
8253                        .put("signingName", "s3express".to_string())
8254                        .put("signingRegion", "us-west-2".to_string())
8255                )
8256                .property("backend", "S3Express".to_string())
8257                .build()
8258        );
8259    }
8260
8261    /// Data Plane sigv4 auth with medium zone (14 chars) fips with AP
8262    #[test]
8263    fn test_324() {
8264        let params = crate::config::endpoint::Params::builder()
8265            .region("us-west-2".to_string())
8266            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
8267            .use_fips(true)
8268            .use_dual_stack(false)
8269            .accelerate(false)
8270            .use_s3_express_control_endpoint(false)
8271            .disable_s3_express_session_auth(true)
8272            .build()
8273            .expect("invalid params");
8274        let resolver = crate::config::endpoint::DefaultResolver::new();
8275        let endpoint = resolver.resolve_endpoint(&params);
8276        let endpoint = endpoint
8277            .expect("Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com");
8278        assert_eq!(
8279            endpoint,
8280            ::aws_smithy_types::endpoint::Endpoint::builder()
8281                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.us-west-2.amazonaws.com")
8282                .auth_scheme(
8283                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8284                        .put("disableDoubleEncoding", true)
8285                        .put("signingName", "s3express".to_string())
8286                        .put("signingRegion", "us-west-2".to_string())
8287                )
8288                .property("backend", "S3Express".to_string())
8289                .build()
8290        );
8291    }
8292
8293    /// Data Plane sigv4 auth with long zone (20 chars) fips
8294    #[test]
8295    fn test_325() {
8296        let params = crate::config::endpoint::Params::builder()
8297            .region("us-west-2".to_string())
8298            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
8299            .use_fips(true)
8300            .use_dual_stack(false)
8301            .accelerate(false)
8302            .use_s3_express_control_endpoint(false)
8303            .disable_s3_express_session_auth(true)
8304            .build()
8305            .expect("invalid params");
8306        let resolver = crate::config::endpoint::DefaultResolver::new();
8307        let endpoint = resolver.resolve_endpoint(&params);
8308        let endpoint = endpoint.expect(
8309            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
8310        );
8311        assert_eq!(
8312            endpoint,
8313            ::aws_smithy_types::endpoint::Endpoint::builder()
8314                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
8315                .auth_scheme(
8316                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8317                        .put("disableDoubleEncoding", true)
8318                        .put("signingName", "s3express".to_string())
8319                        .put("signingRegion", "us-west-2".to_string())
8320                )
8321                .property("backend", "S3Express".to_string())
8322                .build()
8323        );
8324    }
8325
8326    /// Data Plane sigv4 auth with long zone (20 chars) fips with AP
8327    #[test]
8328    fn test_326() {
8329        let params = crate::config::endpoint::Params::builder()
8330            .region("us-west-2".to_string())
8331            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
8332            .use_fips(true)
8333            .use_dual_stack(false)
8334            .accelerate(false)
8335            .use_s3_express_control_endpoint(false)
8336            .disable_s3_express_session_auth(true)
8337            .build()
8338            .expect("invalid params");
8339        let resolver = crate::config::endpoint::DefaultResolver::new();
8340        let endpoint = resolver.resolve_endpoint(&params);
8341        let endpoint = endpoint.expect(
8342            "Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com",
8343        );
8344        assert_eq!(
8345            endpoint,
8346            ::aws_smithy_types::endpoint::Endpoint::builder()
8347                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.us-west-2.amazonaws.com")
8348                .auth_scheme(
8349                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8350                        .put("disableDoubleEncoding", true)
8351                        .put("signingName", "s3express".to_string())
8352                        .put("signingRegion", "us-west-2".to_string())
8353                )
8354                .property("backend", "S3Express".to_string())
8355                .build()
8356        );
8357    }
8358
8359    /// Control Plane host override
8360    #[test]
8361    fn test_327() {
8362        let params = crate::config::endpoint::Params::builder()
8363            .region("us-west-2".to_string())
8364            .bucket("mybucket--usw2-az1--x-s3".to_string())
8365            .use_fips(false)
8366            .use_dual_stack(false)
8367            .accelerate(false)
8368            .use_s3_express_control_endpoint(true)
8369            .disable_s3_express_session_auth(true)
8370            .endpoint("https://custom.com".to_string())
8371            .build()
8372            .expect("invalid params");
8373        let resolver = crate::config::endpoint::DefaultResolver::new();
8374        let endpoint = resolver.resolve_endpoint(&params);
8375        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
8376        assert_eq!(
8377            endpoint,
8378            ::aws_smithy_types::endpoint::Endpoint::builder()
8379                .url("https://mybucket--usw2-az1--x-s3.custom.com")
8380                .auth_scheme(
8381                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8382                        .put("disableDoubleEncoding", true)
8383                        .put("signingName", "s3express".to_string())
8384                        .put("signingRegion", "us-west-2".to_string())
8385                )
8386                .property("backend", "S3Express".to_string())
8387                .build()
8388        );
8389    }
8390
8391    /// Control Plane host override with AP
8392    #[test]
8393    fn test_328() {
8394        let params = crate::config::endpoint::Params::builder()
8395            .region("us-west-2".to_string())
8396            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
8397            .use_fips(false)
8398            .use_dual_stack(false)
8399            .accelerate(false)
8400            .use_s3_express_control_endpoint(true)
8401            .disable_s3_express_session_auth(true)
8402            .endpoint("https://custom.com".to_string())
8403            .build()
8404            .expect("invalid params");
8405        let resolver = crate::config::endpoint::DefaultResolver::new();
8406        let endpoint = resolver.resolve_endpoint(&params);
8407        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.custom.com");
8408        assert_eq!(
8409            endpoint,
8410            ::aws_smithy_types::endpoint::Endpoint::builder()
8411                .url("https://myaccesspoint--usw2-az1--xa-s3.custom.com")
8412                .auth_scheme(
8413                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8414                        .put("disableDoubleEncoding", true)
8415                        .put("signingName", "s3express".to_string())
8416                        .put("signingRegion", "us-west-2".to_string())
8417                )
8418                .property("backend", "S3Express".to_string())
8419                .build()
8420        );
8421    }
8422
8423    /// Control Plane host override no bucket
8424    #[test]
8425    fn test_329() {
8426        let params = crate::config::endpoint::Params::builder()
8427            .region("us-west-2".to_string())
8428            .use_fips(false)
8429            .use_dual_stack(false)
8430            .accelerate(false)
8431            .use_s3_express_control_endpoint(true)
8432            .disable_s3_express_session_auth(true)
8433            .endpoint("https://custom.com".to_string())
8434            .build()
8435            .expect("invalid params");
8436        let resolver = crate::config::endpoint::DefaultResolver::new();
8437        let endpoint = resolver.resolve_endpoint(&params);
8438        let endpoint = endpoint.expect("Expected valid endpoint: https://custom.com");
8439        assert_eq!(
8440            endpoint,
8441            ::aws_smithy_types::endpoint::Endpoint::builder()
8442                .url("https://custom.com")
8443                .auth_scheme(
8444                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8445                        .put("disableDoubleEncoding", true)
8446                        .put("signingName", "s3express".to_string())
8447                        .put("signingRegion", "us-west-2".to_string())
8448                )
8449                .property("backend", "S3Express".to_string())
8450                .build()
8451        );
8452    }
8453
8454    /// Data plane host override non virtual session auth
8455    #[test]
8456    fn test_330() {
8457        let params = crate::config::endpoint::Params::builder()
8458            .region("us-west-2".to_string())
8459            .bucket("mybucket--usw2-az1--x-s3".to_string())
8460            .use_fips(false)
8461            .use_dual_stack(false)
8462            .accelerate(false)
8463            .endpoint("https://10.0.0.1".to_string())
8464            .build()
8465            .expect("invalid params");
8466        let resolver = crate::config::endpoint::DefaultResolver::new();
8467        let endpoint = resolver.resolve_endpoint(&params);
8468        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
8469        assert_eq!(
8470            endpoint,
8471            ::aws_smithy_types::endpoint::Endpoint::builder()
8472                .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
8473                .auth_scheme(
8474                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
8475                        .put("disableDoubleEncoding", true)
8476                        .put("signingName", "s3express".to_string())
8477                        .put("signingRegion", "us-west-2".to_string())
8478                )
8479                .property("backend", "S3Express".to_string())
8480                .build()
8481        );
8482    }
8483
8484    /// Data plane host override non virtual session auth with AP
8485    #[test]
8486    fn test_331() {
8487        let params = crate::config::endpoint::Params::builder()
8488            .region("us-west-2".to_string())
8489            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
8490            .use_fips(false)
8491            .use_dual_stack(false)
8492            .accelerate(false)
8493            .endpoint("https://10.0.0.1".to_string())
8494            .build()
8495            .expect("invalid params");
8496        let resolver = crate::config::endpoint::DefaultResolver::new();
8497        let endpoint = resolver.resolve_endpoint(&params);
8498        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3");
8499        assert_eq!(
8500            endpoint,
8501            ::aws_smithy_types::endpoint::Endpoint::builder()
8502                .url("https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3")
8503                .auth_scheme(
8504                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
8505                        .put("disableDoubleEncoding", true)
8506                        .put("signingName", "s3express".to_string())
8507                        .put("signingRegion", "us-west-2".to_string())
8508                )
8509                .property("backend", "S3Express".to_string())
8510                .build()
8511        );
8512    }
8513
8514    /// Control Plane host override ip
8515    #[test]
8516    fn test_332() {
8517        let params = crate::config::endpoint::Params::builder()
8518            .region("us-west-2".to_string())
8519            .bucket("mybucket--usw2-az1--x-s3".to_string())
8520            .use_fips(false)
8521            .use_dual_stack(false)
8522            .accelerate(false)
8523            .use_s3_express_control_endpoint(true)
8524            .disable_s3_express_session_auth(true)
8525            .endpoint("https://10.0.0.1".to_string())
8526            .build()
8527            .expect("invalid params");
8528        let resolver = crate::config::endpoint::DefaultResolver::new();
8529        let endpoint = resolver.resolve_endpoint(&params);
8530        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/mybucket--usw2-az1--x-s3");
8531        assert_eq!(
8532            endpoint,
8533            ::aws_smithy_types::endpoint::Endpoint::builder()
8534                .url("https://10.0.0.1/mybucket--usw2-az1--x-s3")
8535                .auth_scheme(
8536                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8537                        .put("disableDoubleEncoding", true)
8538                        .put("signingName", "s3express".to_string())
8539                        .put("signingRegion", "us-west-2".to_string())
8540                )
8541                .property("backend", "S3Express".to_string())
8542                .build()
8543        );
8544    }
8545
8546    /// Control Plane host override ip with AP
8547    #[test]
8548    fn test_333() {
8549        let params = crate::config::endpoint::Params::builder()
8550            .region("us-west-2".to_string())
8551            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
8552            .use_fips(false)
8553            .use_dual_stack(false)
8554            .accelerate(false)
8555            .use_s3_express_control_endpoint(true)
8556            .disable_s3_express_session_auth(true)
8557            .endpoint("https://10.0.0.1".to_string())
8558            .build()
8559            .expect("invalid params");
8560        let resolver = crate::config::endpoint::DefaultResolver::new();
8561        let endpoint = resolver.resolve_endpoint(&params);
8562        let endpoint = endpoint.expect("Expected valid endpoint: https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3");
8563        assert_eq!(
8564            endpoint,
8565            ::aws_smithy_types::endpoint::Endpoint::builder()
8566                .url("https://10.0.0.1/myaccesspoint--usw2-az1--xa-s3")
8567                .auth_scheme(
8568                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8569                        .put("disableDoubleEncoding", true)
8570                        .put("signingName", "s3express".to_string())
8571                        .put("signingRegion", "us-west-2".to_string())
8572                )
8573                .property("backend", "S3Express".to_string())
8574                .build()
8575        );
8576    }
8577
8578    /// Data plane host override
8579    #[test]
8580    fn test_334() {
8581        let params = crate::config::endpoint::Params::builder()
8582            .region("us-west-2".to_string())
8583            .bucket("mybucket--usw2-az1--x-s3".to_string())
8584            .use_fips(false)
8585            .use_dual_stack(false)
8586            .accelerate(false)
8587            .endpoint("https://custom.com".to_string())
8588            .build()
8589            .expect("invalid params");
8590        let resolver = crate::config::endpoint::DefaultResolver::new();
8591        let endpoint = resolver.resolve_endpoint(&params);
8592        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.custom.com");
8593        assert_eq!(
8594            endpoint,
8595            ::aws_smithy_types::endpoint::Endpoint::builder()
8596                .url("https://mybucket--usw2-az1--x-s3.custom.com")
8597                .auth_scheme(
8598                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
8599                        .put("disableDoubleEncoding", true)
8600                        .put("signingName", "s3express".to_string())
8601                        .put("signingRegion", "us-west-2".to_string())
8602                )
8603                .property("backend", "S3Express".to_string())
8604                .build()
8605        );
8606    }
8607
8608    /// Data plane host override with AP
8609    #[test]
8610    fn test_335() {
8611        let params = crate::config::endpoint::Params::builder()
8612            .region("us-west-2".to_string())
8613            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
8614            .use_fips(false)
8615            .use_dual_stack(false)
8616            .accelerate(false)
8617            .endpoint("https://custom.com".to_string())
8618            .build()
8619            .expect("invalid params");
8620        let resolver = crate::config::endpoint::DefaultResolver::new();
8621        let endpoint = resolver.resolve_endpoint(&params);
8622        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.custom.com");
8623        assert_eq!(
8624            endpoint,
8625            ::aws_smithy_types::endpoint::Endpoint::builder()
8626                .url("https://myaccesspoint--usw2-az1--xa-s3.custom.com")
8627                .auth_scheme(
8628                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
8629                        .put("disableDoubleEncoding", true)
8630                        .put("signingName", "s3express".to_string())
8631                        .put("signingRegion", "us-west-2".to_string())
8632                )
8633                .property("backend", "S3Express".to_string())
8634                .build()
8635        );
8636    }
8637
8638    /// bad format error
8639    #[test]
8640    fn test_336() {
8641        let params = crate::config::endpoint::Params::builder()
8642            .region("us-east-1".to_string())
8643            .bucket("mybucket--usaz1--x-s3".to_string())
8644            .use_fips(false)
8645            .use_dual_stack(false)
8646            .accelerate(false)
8647            .use_s3_express_control_endpoint(false)
8648            .build()
8649            .expect("invalid params");
8650        let resolver = crate::config::endpoint::DefaultResolver::new();
8651        let endpoint = resolver.resolve_endpoint(&params);
8652        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad format error]");
8653        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
8654    }
8655
8656    /// bad AP format error
8657    #[test]
8658    fn test_337() {
8659        let params = crate::config::endpoint::Params::builder()
8660            .region("us-east-1".to_string())
8661            .bucket("myaccesspoint--usaz1--xa-s3".to_string())
8662            .use_fips(false)
8663            .use_dual_stack(false)
8664            .accelerate(false)
8665            .use_s3_express_control_endpoint(false)
8666            .build()
8667            .expect("invalid params");
8668        let resolver = crate::config::endpoint::DefaultResolver::new();
8669        let endpoint = resolver.resolve_endpoint(&params);
8670        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad AP format error]");
8671        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
8672    }
8673
8674    /// bad format error no session auth
8675    #[test]
8676    fn test_338() {
8677        let params = crate::config::endpoint::Params::builder()
8678            .region("us-east-1".to_string())
8679            .bucket("mybucket--usaz1--x-s3".to_string())
8680            .use_fips(false)
8681            .use_dual_stack(false)
8682            .accelerate(false)
8683            .use_s3_express_control_endpoint(false)
8684            .disable_s3_express_session_auth(true)
8685            .build()
8686            .expect("invalid params");
8687        let resolver = crate::config::endpoint::DefaultResolver::new();
8688        let endpoint = resolver.resolve_endpoint(&params);
8689        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad format error no session auth]");
8690        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
8691    }
8692
8693    /// bad AP format error no session auth
8694    #[test]
8695    fn test_339() {
8696        let params = crate::config::endpoint::Params::builder()
8697            .region("us-east-1".to_string())
8698            .bucket("myaccesspoint--usaz1--xa-s3".to_string())
8699            .use_fips(false)
8700            .use_dual_stack(false)
8701            .accelerate(false)
8702            .use_s3_express_control_endpoint(false)
8703            .disable_s3_express_session_auth(true)
8704            .build()
8705            .expect("invalid params");
8706        let resolver = crate::config::endpoint::DefaultResolver::new();
8707        let endpoint = resolver.resolve_endpoint(&params);
8708        let error = endpoint.expect_err("expected error: Unrecognized S3Express bucket name format. [bad AP format error no session auth]");
8709        assert_eq!(format!("{}", error), "Unrecognized S3Express bucket name format.")
8710    }
8711
8712    /// accelerate error
8713    #[test]
8714    fn test_340() {
8715        let params = crate::config::endpoint::Params::builder()
8716            .region("us-east-1".to_string())
8717            .bucket("mybucket--test-ab1--x-s3".to_string())
8718            .use_fips(false)
8719            .use_dual_stack(false)
8720            .accelerate(true)
8721            .use_s3_express_control_endpoint(false)
8722            .build()
8723            .expect("invalid params");
8724        let resolver = crate::config::endpoint::DefaultResolver::new();
8725        let endpoint = resolver.resolve_endpoint(&params);
8726        let error = endpoint.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error]");
8727        assert_eq!(format!("{}", error), "S3Express does not support S3 Accelerate.")
8728    }
8729
8730    /// accelerate error with AP
8731    #[test]
8732    fn test_341() {
8733        let params = crate::config::endpoint::Params::builder()
8734            .region("us-east-1".to_string())
8735            .bucket("myaccesspoint--test-ab1--xa-s3".to_string())
8736            .use_fips(false)
8737            .use_dual_stack(false)
8738            .accelerate(true)
8739            .use_s3_express_control_endpoint(false)
8740            .build()
8741            .expect("invalid params");
8742        let resolver = crate::config::endpoint::DefaultResolver::new();
8743        let endpoint = resolver.resolve_endpoint(&params);
8744        let error = endpoint.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error with AP]");
8745        assert_eq!(format!("{}", error), "S3Express does not support S3 Accelerate.")
8746    }
8747
8748    /// Data plane bucket format error
8749    #[test]
8750    fn test_342() {
8751        let params = crate::config::endpoint::Params::builder()
8752            .region("us-east-1".to_string())
8753            .bucket("my.bucket--test-ab1--x-s3".to_string())
8754            .use_fips(false)
8755            .use_dual_stack(false)
8756            .accelerate(false)
8757            .use_s3_express_control_endpoint(false)
8758            .build()
8759            .expect("invalid params");
8760        let resolver = crate::config::endpoint::DefaultResolver::new();
8761        let endpoint = resolver.resolve_endpoint(&params);
8762        let error =
8763            endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane bucket format error]");
8764        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8765    }
8766
8767    /// Data plane AP format error
8768    #[test]
8769    fn test_343() {
8770        let params = crate::config::endpoint::Params::builder()
8771            .region("us-east-1".to_string())
8772            .bucket("my.myaccesspoint--test-ab1--xa-s3".to_string())
8773            .use_fips(false)
8774            .use_dual_stack(false)
8775            .accelerate(false)
8776            .use_s3_express_control_endpoint(false)
8777            .build()
8778            .expect("invalid params");
8779        let resolver = crate::config::endpoint::DefaultResolver::new();
8780        let endpoint = resolver.resolve_endpoint(&params);
8781        let error = endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane AP format error]");
8782        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8783    }
8784
8785    /// host override data plane bucket error session auth
8786    #[test]
8787    fn test_344() {
8788        let params = crate::config::endpoint::Params::builder()
8789            .region("us-west-2".to_string())
8790            .bucket("my.bucket--usw2-az1--x-s3".to_string())
8791            .use_fips(false)
8792            .use_dual_stack(false)
8793            .accelerate(false)
8794            .endpoint("https://custom.com".to_string())
8795            .build()
8796            .expect("invalid params");
8797        let resolver = crate::config::endpoint::DefaultResolver::new();
8798        let endpoint = resolver.resolve_endpoint(&params);
8799        let error = endpoint.expect_err(
8800            "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error session auth]",
8801        );
8802        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8803    }
8804
8805    /// host override data plane AP error session auth
8806    #[test]
8807    fn test_345() {
8808        let params = crate::config::endpoint::Params::builder()
8809            .region("us-west-2".to_string())
8810            .bucket("my.myaccesspoint--usw2-az1--xa-s3".to_string())
8811            .use_fips(false)
8812            .use_dual_stack(false)
8813            .accelerate(false)
8814            .endpoint("https://custom.com".to_string())
8815            .build()
8816            .expect("invalid params");
8817        let resolver = crate::config::endpoint::DefaultResolver::new();
8818        let endpoint = resolver.resolve_endpoint(&params);
8819        let error = endpoint.expect_err(
8820            "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane AP error session auth]",
8821        );
8822        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8823    }
8824
8825    /// host override data plane bucket error
8826    #[test]
8827    fn test_346() {
8828        let params = crate::config::endpoint::Params::builder()
8829            .region("us-west-2".to_string())
8830            .bucket("my.bucket--usw2-az1--x-s3".to_string())
8831            .use_fips(false)
8832            .use_dual_stack(false)
8833            .accelerate(false)
8834            .endpoint("https://custom.com".to_string())
8835            .disable_s3_express_session_auth(true)
8836            .build()
8837            .expect("invalid params");
8838        let resolver = crate::config::endpoint::DefaultResolver::new();
8839        let endpoint = resolver.resolve_endpoint(&params);
8840        let error = endpoint
8841            .expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error]");
8842        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8843    }
8844
8845    /// host override data plane AP error
8846    #[test]
8847    fn test_347() {
8848        let params = crate::config::endpoint::Params::builder()
8849            .region("us-west-2".to_string())
8850            .bucket("my.myaccesspoint--usw2-az1--xa-s3".to_string())
8851            .use_fips(false)
8852            .use_dual_stack(false)
8853            .accelerate(false)
8854            .endpoint("https://custom.com".to_string())
8855            .disable_s3_express_session_auth(true)
8856            .build()
8857            .expect("invalid params");
8858        let resolver = crate::config::endpoint::DefaultResolver::new();
8859        let endpoint = resolver.resolve_endpoint(&params);
8860        let error =
8861            endpoint.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane AP error]");
8862        assert_eq!(format!("{}", error), "S3Express bucket name is not a valid virtual hostable name.")
8863    }
8864
8865    /// Control plane without bucket and dualstack
8866    #[test]
8867    fn test_348() {
8868        let params = crate::config::endpoint::Params::builder()
8869            .region("us-east-1".to_string())
8870            .use_fips(false)
8871            .use_dual_stack(true)
8872            .accelerate(false)
8873            .use_s3_express_control_endpoint(true)
8874            .disable_s3_express_session_auth(false)
8875            .build()
8876            .expect("invalid params");
8877        let resolver = crate::config::endpoint::DefaultResolver::new();
8878        let endpoint = resolver.resolve_endpoint(&params);
8879        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.dualstack.us-east-1.amazonaws.com");
8880        assert_eq!(
8881            endpoint,
8882            ::aws_smithy_types::endpoint::Endpoint::builder()
8883                .url("https://s3express-control.dualstack.us-east-1.amazonaws.com")
8884                .auth_scheme(
8885                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8886                        .put("disableDoubleEncoding", true)
8887                        .put("signingName", "s3express".to_string())
8888                        .put("signingRegion", "us-east-1".to_string())
8889                )
8890                .property("backend", "S3Express".to_string())
8891                .build()
8892        );
8893    }
8894
8895    /// Control plane without bucket, fips and dualstack
8896    #[test]
8897    fn test_349() {
8898        let params = crate::config::endpoint::Params::builder()
8899            .region("us-east-1".to_string())
8900            .use_fips(true)
8901            .use_dual_stack(true)
8902            .accelerate(false)
8903            .use_s3_express_control_endpoint(true)
8904            .disable_s3_express_session_auth(false)
8905            .build()
8906            .expect("invalid params");
8907        let resolver = crate::config::endpoint::DefaultResolver::new();
8908        let endpoint = resolver.resolve_endpoint(&params);
8909        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control-fips.dualstack.us-east-1.amazonaws.com");
8910        assert_eq!(
8911            endpoint,
8912            ::aws_smithy_types::endpoint::Endpoint::builder()
8913                .url("https://s3express-control-fips.dualstack.us-east-1.amazonaws.com")
8914                .auth_scheme(
8915                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8916                        .put("disableDoubleEncoding", true)
8917                        .put("signingName", "s3express".to_string())
8918                        .put("signingRegion", "us-east-1".to_string())
8919                )
8920                .property("backend", "S3Express".to_string())
8921                .build()
8922        );
8923    }
8924
8925    /// Data Plane with bucket containing delimiters
8926    #[test]
8927    fn test_350() {
8928        let params = crate::config::endpoint::Params::builder()
8929            .region("us-east-1".to_string())
8930            .bucket("my--s3--bucket--abcd-ab1--x-s3".to_string())
8931            .use_fips(false)
8932            .use_dual_stack(false)
8933            .accelerate(false)
8934            .use_s3_express_control_endpoint(false)
8935            .build()
8936            .expect("invalid params");
8937        let resolver = crate::config::endpoint::DefaultResolver::new();
8938        let endpoint = resolver.resolve_endpoint(&params);
8939        let endpoint = endpoint.expect("Expected valid endpoint: https://my--s3--bucket--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com");
8940        assert_eq!(
8941            endpoint,
8942            ::aws_smithy_types::endpoint::Endpoint::builder()
8943                .url("https://my--s3--bucket--abcd-ab1--x-s3.s3express-abcd-ab1.us-east-1.amazonaws.com")
8944                .auth_scheme(
8945                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
8946                        .put("disableDoubleEncoding", true)
8947                        .put("signingName", "s3express".to_string())
8948                        .put("signingRegion", "us-east-1".to_string())
8949                )
8950                .property("backend", "S3Express".to_string())
8951                .build()
8952        );
8953    }
8954
8955    /// Control plane with with bucket containing delimiters
8956    #[test]
8957    fn test_351() {
8958        let params = crate::config::endpoint::Params::builder()
8959            .region("us-east-1".to_string())
8960            .bucket("my--s3--bucket--abcd-ab1--x-s3".to_string())
8961            .use_fips(false)
8962            .use_dual_stack(false)
8963            .accelerate(false)
8964            .use_s3_express_control_endpoint(true)
8965            .disable_s3_express_session_auth(false)
8966            .build()
8967            .expect("invalid params");
8968        let resolver = crate::config::endpoint::DefaultResolver::new();
8969        let endpoint = resolver.resolve_endpoint(&params);
8970        let endpoint = endpoint.expect("Expected valid endpoint: https://s3express-control.us-east-1.amazonaws.com/my--s3--bucket--abcd-ab1--x-s3");
8971        assert_eq!(
8972            endpoint,
8973            ::aws_smithy_types::endpoint::Endpoint::builder()
8974                .url("https://s3express-control.us-east-1.amazonaws.com/my--s3--bucket--abcd-ab1--x-s3")
8975                .auth_scheme(
8976                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
8977                        .put("disableDoubleEncoding", true)
8978                        .put("signingName", "s3express".to_string())
8979                        .put("signingRegion", "us-east-1".to_string())
8980                )
8981                .property("backend", "S3Express".to_string())
8982                .build()
8983        );
8984    }
8985
8986    /// Data Plane with short AZ and dualstack
8987    #[test]
8988    fn test_352() {
8989        let params = crate::config::endpoint::Params::builder()
8990            .region("us-west-2".to_string())
8991            .bucket("mybucket--usw2-az1--x-s3".to_string())
8992            .use_fips(false)
8993            .use_dual_stack(true)
8994            .accelerate(false)
8995            .use_s3_express_control_endpoint(false)
8996            .build()
8997            .expect("invalid params");
8998        let resolver = crate::config::endpoint::DefaultResolver::new();
8999        let endpoint = resolver.resolve_endpoint(&params);
9000        let endpoint =
9001            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
9002        assert_eq!(
9003            endpoint,
9004            ::aws_smithy_types::endpoint::Endpoint::builder()
9005                .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
9006                .auth_scheme(
9007                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9008                        .put("disableDoubleEncoding", true)
9009                        .put("signingName", "s3express".to_string())
9010                        .put("signingRegion", "us-west-2".to_string())
9011                )
9012                .property("backend", "S3Express".to_string())
9013                .build()
9014        );
9015    }
9016
9017    /// Data Plane with short AZ and FIPS with dualstack
9018    #[test]
9019    fn test_353() {
9020        let params = crate::config::endpoint::Params::builder()
9021            .region("us-west-2".to_string())
9022            .bucket("mybucket--usw2-az1--x-s3".to_string())
9023            .use_fips(true)
9024            .use_dual_stack(true)
9025            .accelerate(false)
9026            .use_s3_express_control_endpoint(false)
9027            .build()
9028            .expect("invalid params");
9029        let resolver = crate::config::endpoint::DefaultResolver::new();
9030        let endpoint = resolver.resolve_endpoint(&params);
9031        let endpoint =
9032            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
9033        assert_eq!(
9034            endpoint,
9035            ::aws_smithy_types::endpoint::Endpoint::builder()
9036                .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
9037                .auth_scheme(
9038                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9039                        .put("disableDoubleEncoding", true)
9040                        .put("signingName", "s3express".to_string())
9041                        .put("signingRegion", "us-west-2".to_string())
9042                )
9043                .property("backend", "S3Express".to_string())
9044                .build()
9045        );
9046    }
9047
9048    /// Data Plane sigv4 auth with short AZ and dualstack
9049    #[test]
9050    fn test_354() {
9051        let params = crate::config::endpoint::Params::builder()
9052            .region("us-west-2".to_string())
9053            .bucket("mybucket--usw2-az1--x-s3".to_string())
9054            .use_fips(false)
9055            .use_dual_stack(true)
9056            .accelerate(false)
9057            .disable_s3_express_session_auth(true)
9058            .build()
9059            .expect("invalid params");
9060        let resolver = crate::config::endpoint::DefaultResolver::new();
9061        let endpoint = resolver.resolve_endpoint(&params);
9062        let endpoint =
9063            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
9064        assert_eq!(
9065            endpoint,
9066            ::aws_smithy_types::endpoint::Endpoint::builder()
9067                .url("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
9068                .auth_scheme(
9069                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9070                        .put("disableDoubleEncoding", true)
9071                        .put("signingName", "s3express".to_string())
9072                        .put("signingRegion", "us-west-2".to_string())
9073                )
9074                .property("backend", "S3Express".to_string())
9075                .build()
9076        );
9077    }
9078
9079    /// Data Plane sigv4 auth with short AZ and FIPS with dualstack
9080    #[test]
9081    fn test_355() {
9082        let params = crate::config::endpoint::Params::builder()
9083            .region("us-west-2".to_string())
9084            .bucket("mybucket--usw2-az1--x-s3".to_string())
9085            .use_fips(true)
9086            .use_dual_stack(true)
9087            .accelerate(false)
9088            .disable_s3_express_session_auth(true)
9089            .build()
9090            .expect("invalid params");
9091        let resolver = crate::config::endpoint::DefaultResolver::new();
9092        let endpoint = resolver.resolve_endpoint(&params);
9093        let endpoint =
9094            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
9095        assert_eq!(
9096            endpoint,
9097            ::aws_smithy_types::endpoint::Endpoint::builder()
9098                .url("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
9099                .auth_scheme(
9100                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9101                        .put("disableDoubleEncoding", true)
9102                        .put("signingName", "s3express".to_string())
9103                        .put("signingRegion", "us-west-2".to_string())
9104                )
9105                .property("backend", "S3Express".to_string())
9106                .build()
9107        );
9108    }
9109
9110    /// Data Plane with zone and dualstack
9111    #[test]
9112    fn test_356() {
9113        let params = crate::config::endpoint::Params::builder()
9114            .region("us-west-2".to_string())
9115            .bucket("mybucket--usw2-az12--x-s3".to_string())
9116            .use_fips(false)
9117            .use_dual_stack(true)
9118            .accelerate(false)
9119            .use_s3_express_control_endpoint(false)
9120            .build()
9121            .expect("invalid params");
9122        let resolver = crate::config::endpoint::DefaultResolver::new();
9123        let endpoint = resolver.resolve_endpoint(&params);
9124        let endpoint =
9125            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
9126        assert_eq!(
9127            endpoint,
9128            ::aws_smithy_types::endpoint::Endpoint::builder()
9129                .url("https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
9130                .auth_scheme(
9131                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9132                        .put("disableDoubleEncoding", true)
9133                        .put("signingName", "s3express".to_string())
9134                        .put("signingRegion", "us-west-2".to_string())
9135                )
9136                .property("backend", "S3Express".to_string())
9137                .build()
9138        );
9139    }
9140
9141    /// Data Plane with zone and FIPS with dualstack
9142    #[test]
9143    fn test_357() {
9144        let params = crate::config::endpoint::Params::builder()
9145            .region("us-west-2".to_string())
9146            .bucket("mybucket--usw2-az12--x-s3".to_string())
9147            .use_fips(true)
9148            .use_dual_stack(true)
9149            .accelerate(false)
9150            .use_s3_express_control_endpoint(false)
9151            .build()
9152            .expect("invalid params");
9153        let resolver = crate::config::endpoint::DefaultResolver::new();
9154        let endpoint = resolver.resolve_endpoint(&params);
9155        let endpoint =
9156            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
9157        assert_eq!(
9158            endpoint,
9159            ::aws_smithy_types::endpoint::Endpoint::builder()
9160                .url("https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
9161                .auth_scheme(
9162                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9163                        .put("disableDoubleEncoding", true)
9164                        .put("signingName", "s3express".to_string())
9165                        .put("signingRegion", "us-west-2".to_string())
9166                )
9167                .property("backend", "S3Express".to_string())
9168                .build()
9169        );
9170    }
9171
9172    /// Data Plane sigv4 auth with zone and dualstack
9173    #[test]
9174    fn test_358() {
9175        let params = crate::config::endpoint::Params::builder()
9176            .region("us-west-2".to_string())
9177            .bucket("mybucket--usw2-az12--x-s3".to_string())
9178            .use_fips(false)
9179            .use_dual_stack(true)
9180            .accelerate(false)
9181            .disable_s3_express_session_auth(true)
9182            .build()
9183            .expect("invalid params");
9184        let resolver = crate::config::endpoint::DefaultResolver::new();
9185        let endpoint = resolver.resolve_endpoint(&params);
9186        let endpoint =
9187            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
9188        assert_eq!(
9189            endpoint,
9190            ::aws_smithy_types::endpoint::Endpoint::builder()
9191                .url("https://mybucket--usw2-az12--x-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
9192                .auth_scheme(
9193                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9194                        .put("disableDoubleEncoding", true)
9195                        .put("signingName", "s3express".to_string())
9196                        .put("signingRegion", "us-west-2".to_string())
9197                )
9198                .property("backend", "S3Express".to_string())
9199                .build()
9200        );
9201    }
9202
9203    /// Data Plane sigv4 auth with 9-char zone and FIPS with dualstack
9204    #[test]
9205    fn test_359() {
9206        let params = crate::config::endpoint::Params::builder()
9207            .region("us-west-2".to_string())
9208            .bucket("mybucket--usw2-az12--x-s3".to_string())
9209            .use_fips(true)
9210            .use_dual_stack(true)
9211            .accelerate(false)
9212            .disable_s3_express_session_auth(true)
9213            .build()
9214            .expect("invalid params");
9215        let resolver = crate::config::endpoint::DefaultResolver::new();
9216        let endpoint = resolver.resolve_endpoint(&params);
9217        let endpoint =
9218            endpoint.expect("Expected valid endpoint: https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
9219        assert_eq!(
9220            endpoint,
9221            ::aws_smithy_types::endpoint::Endpoint::builder()
9222                .url("https://mybucket--usw2-az12--x-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
9223                .auth_scheme(
9224                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9225                        .put("disableDoubleEncoding", true)
9226                        .put("signingName", "s3express".to_string())
9227                        .put("signingRegion", "us-west-2".to_string())
9228                )
9229                .property("backend", "S3Express".to_string())
9230                .build()
9231        );
9232    }
9233
9234    /// Data Plane with 13-char zone and dualstack
9235    #[test]
9236    fn test_360() {
9237        let params = crate::config::endpoint::Params::builder()
9238            .region("us-west-2".to_string())
9239            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
9240            .use_fips(false)
9241            .use_dual_stack(true)
9242            .accelerate(false)
9243            .use_s3_express_control_endpoint(false)
9244            .build()
9245            .expect("invalid params");
9246        let resolver = crate::config::endpoint::DefaultResolver::new();
9247        let endpoint = resolver.resolve_endpoint(&params);
9248        let endpoint = endpoint
9249            .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
9250        assert_eq!(
9251            endpoint,
9252            ::aws_smithy_types::endpoint::Endpoint::builder()
9253                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
9254                .auth_scheme(
9255                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9256                        .put("disableDoubleEncoding", true)
9257                        .put("signingName", "s3express".to_string())
9258                        .put("signingRegion", "us-west-2".to_string())
9259                )
9260                .property("backend", "S3Express".to_string())
9261                .build()
9262        );
9263    }
9264
9265    /// Data Plane with 13-char zone and FIPS with dualstack
9266    #[test]
9267    fn test_361() {
9268        let params = crate::config::endpoint::Params::builder()
9269            .region("us-west-2".to_string())
9270            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
9271            .use_fips(true)
9272            .use_dual_stack(true)
9273            .accelerate(false)
9274            .use_s3_express_control_endpoint(false)
9275            .build()
9276            .expect("invalid params");
9277        let resolver = crate::config::endpoint::DefaultResolver::new();
9278        let endpoint = resolver.resolve_endpoint(&params);
9279        let endpoint = endpoint
9280            .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
9281        assert_eq!(
9282            endpoint,
9283            ::aws_smithy_types::endpoint::Endpoint::builder()
9284                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
9285                .auth_scheme(
9286                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9287                        .put("disableDoubleEncoding", true)
9288                        .put("signingName", "s3express".to_string())
9289                        .put("signingRegion", "us-west-2".to_string())
9290                )
9291                .property("backend", "S3Express".to_string())
9292                .build()
9293        );
9294    }
9295
9296    /// Data Plane sigv4 auth with 13-char zone and dualstack
9297    #[test]
9298    fn test_362() {
9299        let params = crate::config::endpoint::Params::builder()
9300            .region("us-west-2".to_string())
9301            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
9302            .use_fips(false)
9303            .use_dual_stack(true)
9304            .accelerate(false)
9305            .disable_s3_express_session_auth(true)
9306            .build()
9307            .expect("invalid params");
9308        let resolver = crate::config::endpoint::DefaultResolver::new();
9309        let endpoint = resolver.resolve_endpoint(&params);
9310        let endpoint = endpoint
9311            .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
9312        assert_eq!(
9313            endpoint,
9314            ::aws_smithy_types::endpoint::Endpoint::builder()
9315                .url("https://mybucket--test-zone-ab1--x-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
9316                .auth_scheme(
9317                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9318                        .put("disableDoubleEncoding", true)
9319                        .put("signingName", "s3express".to_string())
9320                        .put("signingRegion", "us-west-2".to_string())
9321                )
9322                .property("backend", "S3Express".to_string())
9323                .build()
9324        );
9325    }
9326
9327    /// Data Plane sigv4 auth with 13-char zone and FIPS with dualstack
9328    #[test]
9329    fn test_363() {
9330        let params = crate::config::endpoint::Params::builder()
9331            .region("us-west-2".to_string())
9332            .bucket("mybucket--test-zone-ab1--x-s3".to_string())
9333            .use_fips(true)
9334            .use_dual_stack(true)
9335            .accelerate(false)
9336            .disable_s3_express_session_auth(true)
9337            .build()
9338            .expect("invalid params");
9339        let resolver = crate::config::endpoint::DefaultResolver::new();
9340        let endpoint = resolver.resolve_endpoint(&params);
9341        let endpoint = endpoint
9342            .expect("Expected valid endpoint: https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
9343        assert_eq!(
9344            endpoint,
9345            ::aws_smithy_types::endpoint::Endpoint::builder()
9346                .url("https://mybucket--test-zone-ab1--x-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
9347                .auth_scheme(
9348                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9349                        .put("disableDoubleEncoding", true)
9350                        .put("signingName", "s3express".to_string())
9351                        .put("signingRegion", "us-west-2".to_string())
9352                )
9353                .property("backend", "S3Express".to_string())
9354                .build()
9355        );
9356    }
9357
9358    /// Data Plane with 14-char zone and dualstack
9359    #[test]
9360    fn test_364() {
9361        let params = crate::config::endpoint::Params::builder()
9362            .region("us-west-2".to_string())
9363            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
9364            .use_fips(false)
9365            .use_dual_stack(true)
9366            .accelerate(false)
9367            .use_s3_express_control_endpoint(false)
9368            .build()
9369            .expect("invalid params");
9370        let resolver = crate::config::endpoint::DefaultResolver::new();
9371        let endpoint = resolver.resolve_endpoint(&params);
9372        let endpoint = endpoint
9373            .expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com");
9374        assert_eq!(
9375            endpoint,
9376            ::aws_smithy_types::endpoint::Endpoint::builder()
9377                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
9378                .auth_scheme(
9379                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9380                        .put("disableDoubleEncoding", true)
9381                        .put("signingName", "s3express".to_string())
9382                        .put("signingRegion", "us-west-2".to_string())
9383                )
9384                .property("backend", "S3Express".to_string())
9385                .build()
9386        );
9387    }
9388
9389    /// Data Plane with 14-char zone and FIPS with dualstack
9390    #[test]
9391    fn test_365() {
9392        let params = crate::config::endpoint::Params::builder()
9393            .region("us-west-2".to_string())
9394            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
9395            .use_fips(true)
9396            .use_dual_stack(true)
9397            .accelerate(false)
9398            .use_s3_express_control_endpoint(false)
9399            .build()
9400            .expect("invalid params");
9401        let resolver = crate::config::endpoint::DefaultResolver::new();
9402        let endpoint = resolver.resolve_endpoint(&params);
9403        let endpoint = endpoint.expect(
9404            "Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
9405        );
9406        assert_eq!(
9407            endpoint,
9408            ::aws_smithy_types::endpoint::Endpoint::builder()
9409                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
9410                .auth_scheme(
9411                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9412                        .put("disableDoubleEncoding", true)
9413                        .put("signingName", "s3express".to_string())
9414                        .put("signingRegion", "us-west-2".to_string())
9415                )
9416                .property("backend", "S3Express".to_string())
9417                .build()
9418        );
9419    }
9420
9421    /// Data Plane sigv4 auth with 14-char zone and dualstack
9422    #[test]
9423    fn test_366() {
9424        let params = crate::config::endpoint::Params::builder()
9425            .region("us-west-2".to_string())
9426            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
9427            .use_fips(false)
9428            .use_dual_stack(true)
9429            .accelerate(false)
9430            .disable_s3_express_session_auth(true)
9431            .build()
9432            .expect("invalid params");
9433        let resolver = crate::config::endpoint::DefaultResolver::new();
9434        let endpoint = resolver.resolve_endpoint(&params);
9435        let endpoint = endpoint
9436            .expect("Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com");
9437        assert_eq!(
9438            endpoint,
9439            ::aws_smithy_types::endpoint::Endpoint::builder()
9440                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
9441                .auth_scheme(
9442                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9443                        .put("disableDoubleEncoding", true)
9444                        .put("signingName", "s3express".to_string())
9445                        .put("signingRegion", "us-west-2".to_string())
9446                )
9447                .property("backend", "S3Express".to_string())
9448                .build()
9449        );
9450    }
9451
9452    /// Data Plane sigv4 auth with 14-char zone and FIPS with dualstack
9453    #[test]
9454    fn test_367() {
9455        let params = crate::config::endpoint::Params::builder()
9456            .region("us-west-2".to_string())
9457            .bucket("mybucket--test1-zone-ab1--x-s3".to_string())
9458            .use_fips(true)
9459            .use_dual_stack(true)
9460            .accelerate(false)
9461            .disable_s3_express_session_auth(true)
9462            .build()
9463            .expect("invalid params");
9464        let resolver = crate::config::endpoint::DefaultResolver::new();
9465        let endpoint = resolver.resolve_endpoint(&params);
9466        let endpoint = endpoint.expect(
9467            "Expected valid endpoint: https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
9468        );
9469        assert_eq!(
9470            endpoint,
9471            ::aws_smithy_types::endpoint::Endpoint::builder()
9472                .url("https://mybucket--test1-zone-ab1--x-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
9473                .auth_scheme(
9474                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9475                        .put("disableDoubleEncoding", true)
9476                        .put("signingName", "s3express".to_string())
9477                        .put("signingRegion", "us-west-2".to_string())
9478                )
9479                .property("backend", "S3Express".to_string())
9480                .build()
9481        );
9482    }
9483
9484    /// Data Plane with long zone (20 cha) and dualstack
9485    #[test]
9486    fn test_368() {
9487        let params = crate::config::endpoint::Params::builder()
9488            .region("us-west-2".to_string())
9489            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
9490            .use_fips(false)
9491            .use_dual_stack(true)
9492            .accelerate(false)
9493            .use_s3_express_control_endpoint(false)
9494            .build()
9495            .expect("invalid params");
9496        let resolver = crate::config::endpoint::DefaultResolver::new();
9497        let endpoint = resolver.resolve_endpoint(&params);
9498        let endpoint = endpoint.expect(
9499            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com",
9500        );
9501        assert_eq!(
9502            endpoint,
9503            ::aws_smithy_types::endpoint::Endpoint::builder()
9504                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
9505                .auth_scheme(
9506                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9507                        .put("disableDoubleEncoding", true)
9508                        .put("signingName", "s3express".to_string())
9509                        .put("signingRegion", "us-west-2".to_string())
9510                )
9511                .property("backend", "S3Express".to_string())
9512                .build()
9513        );
9514    }
9515
9516    /// Data Plane with long zone (20 char) and FIPS with dualstack
9517    #[test]
9518    fn test_369() {
9519        let params = crate::config::endpoint::Params::builder()
9520            .region("us-west-2".to_string())
9521            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
9522            .use_fips(true)
9523            .use_dual_stack(true)
9524            .accelerate(false)
9525            .use_s3_express_control_endpoint(false)
9526            .build()
9527            .expect("invalid params");
9528        let resolver = crate::config::endpoint::DefaultResolver::new();
9529        let endpoint = resolver.resolve_endpoint(&params);
9530        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
9531        assert_eq!(
9532            endpoint,
9533            ::aws_smithy_types::endpoint::Endpoint::builder()
9534                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
9535                .auth_scheme(
9536                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9537                        .put("disableDoubleEncoding", true)
9538                        .put("signingName", "s3express".to_string())
9539                        .put("signingRegion", "us-west-2".to_string())
9540                )
9541                .property("backend", "S3Express".to_string())
9542                .build()
9543        );
9544    }
9545
9546    /// Data Plane sigv4 auth with long zone (20 char) and dualstack
9547    #[test]
9548    fn test_370() {
9549        let params = crate::config::endpoint::Params::builder()
9550            .region("us-west-2".to_string())
9551            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
9552            .use_fips(false)
9553            .use_dual_stack(true)
9554            .accelerate(false)
9555            .disable_s3_express_session_auth(true)
9556            .build()
9557            .expect("invalid params");
9558        let resolver = crate::config::endpoint::DefaultResolver::new();
9559        let endpoint = resolver.resolve_endpoint(&params);
9560        let endpoint = endpoint.expect(
9561            "Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com",
9562        );
9563        assert_eq!(
9564            endpoint,
9565            ::aws_smithy_types::endpoint::Endpoint::builder()
9566                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
9567                .auth_scheme(
9568                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9569                        .put("disableDoubleEncoding", true)
9570                        .put("signingName", "s3express".to_string())
9571                        .put("signingRegion", "us-west-2".to_string())
9572                )
9573                .property("backend", "S3Express".to_string())
9574                .build()
9575        );
9576    }
9577
9578    /// Data Plane sigv4 auth with long zone (20 char) and FIPS with dualstack
9579    #[test]
9580    fn test_371() {
9581        let params = crate::config::endpoint::Params::builder()
9582            .region("us-west-2".to_string())
9583            .bucket("mybucket--test1-long1-zone-ab1--x-s3".to_string())
9584            .use_fips(true)
9585            .use_dual_stack(true)
9586            .accelerate(false)
9587            .disable_s3_express_session_auth(true)
9588            .build()
9589            .expect("invalid params");
9590        let resolver = crate::config::endpoint::DefaultResolver::new();
9591        let endpoint = resolver.resolve_endpoint(&params);
9592        let endpoint = endpoint.expect("Expected valid endpoint: https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
9593        assert_eq!(
9594            endpoint,
9595            ::aws_smithy_types::endpoint::Endpoint::builder()
9596                .url("https://mybucket--test1-long1-zone-ab1--x-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
9597                .auth_scheme(
9598                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9599                        .put("disableDoubleEncoding", true)
9600                        .put("signingName", "s3express".to_string())
9601                        .put("signingRegion", "us-west-2".to_string())
9602                )
9603                .property("backend", "S3Express".to_string())
9604                .build()
9605        );
9606    }
9607
9608    /// Control plane and FIPS with dualstack
9609    #[test]
9610    fn test_372() {
9611        let params = crate::config::endpoint::Params::builder()
9612            .region("us-east-1".to_string())
9613            .bucket("mybucket--test-ab1--x-s3".to_string())
9614            .use_fips(true)
9615            .use_dual_stack(true)
9616            .accelerate(false)
9617            .use_s3_express_control_endpoint(true)
9618            .build()
9619            .expect("invalid params");
9620        let resolver = crate::config::endpoint::DefaultResolver::new();
9621        let endpoint = resolver.resolve_endpoint(&params);
9622        let endpoint =
9623            endpoint.expect("Expected valid endpoint: https://s3express-control-fips.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
9624        assert_eq!(
9625            endpoint,
9626            ::aws_smithy_types::endpoint::Endpoint::builder()
9627                .url("https://s3express-control-fips.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
9628                .auth_scheme(
9629                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9630                        .put("disableDoubleEncoding", true)
9631                        .put("signingName", "s3express".to_string())
9632                        .put("signingRegion", "us-east-1".to_string())
9633                )
9634                .property("backend", "S3Express".to_string())
9635                .build()
9636        );
9637    }
9638
9639    /// Data plane with zone and dualstack and AP
9640    #[test]
9641    fn test_373() {
9642        let params = crate::config::endpoint::Params::builder()
9643            .region("us-west-2".to_string())
9644            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
9645            .use_fips(false)
9646            .use_dual_stack(true)
9647            .accelerate(false)
9648            .use_s3_express_control_endpoint(false)
9649            .build()
9650            .expect("invalid params");
9651        let resolver = crate::config::endpoint::DefaultResolver::new();
9652        let endpoint = resolver.resolve_endpoint(&params);
9653        let endpoint =
9654            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
9655        assert_eq!(
9656            endpoint,
9657            ::aws_smithy_types::endpoint::Endpoint::builder()
9658                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
9659                .auth_scheme(
9660                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9661                        .put("disableDoubleEncoding", true)
9662                        .put("signingName", "s3express".to_string())
9663                        .put("signingRegion", "us-west-2".to_string())
9664                )
9665                .property("backend", "S3Express".to_string())
9666                .build()
9667        );
9668    }
9669
9670    /// Data plane with zone and FIPS with dualstack and AP
9671    #[test]
9672    fn test_374() {
9673        let params = crate::config::endpoint::Params::builder()
9674            .region("us-west-2".to_string())
9675            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
9676            .use_fips(true)
9677            .use_dual_stack(true)
9678            .accelerate(false)
9679            .use_s3_express_control_endpoint(false)
9680            .build()
9681            .expect("invalid params");
9682        let resolver = crate::config::endpoint::DefaultResolver::new();
9683        let endpoint = resolver.resolve_endpoint(&params);
9684        let endpoint = endpoint
9685            .expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
9686        assert_eq!(
9687            endpoint,
9688            ::aws_smithy_types::endpoint::Endpoint::builder()
9689                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
9690                .auth_scheme(
9691                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9692                        .put("disableDoubleEncoding", true)
9693                        .put("signingName", "s3express".to_string())
9694                        .put("signingRegion", "us-west-2".to_string())
9695                )
9696                .property("backend", "S3Express".to_string())
9697                .build()
9698        );
9699    }
9700
9701    /// Data Plane sigv4 auth with zone and dualstack and AP
9702    #[test]
9703    fn test_375() {
9704        let params = crate::config::endpoint::Params::builder()
9705            .region("us-west-2".to_string())
9706            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
9707            .use_fips(false)
9708            .use_dual_stack(true)
9709            .accelerate(false)
9710            .disable_s3_express_session_auth(true)
9711            .build()
9712            .expect("invalid params");
9713        let resolver = crate::config::endpoint::DefaultResolver::new();
9714        let endpoint = resolver.resolve_endpoint(&params);
9715        let endpoint =
9716            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com");
9717        assert_eq!(
9718            endpoint,
9719            ::aws_smithy_types::endpoint::Endpoint::builder()
9720                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com")
9721                .auth_scheme(
9722                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9723                        .put("disableDoubleEncoding", true)
9724                        .put("signingName", "s3express".to_string())
9725                        .put("signingRegion", "us-west-2".to_string())
9726                )
9727                .property("backend", "S3Express".to_string())
9728                .build()
9729        );
9730    }
9731
9732    /// Data Plane AP sigv4 auth with zone and FIPS with dualstack
9733    #[test]
9734    fn test_376() {
9735        let params = crate::config::endpoint::Params::builder()
9736            .region("us-west-2".to_string())
9737            .bucket("myaccesspoint--usw2-az1--xa-s3".to_string())
9738            .use_fips(true)
9739            .use_dual_stack(true)
9740            .accelerate(false)
9741            .disable_s3_express_session_auth(true)
9742            .build()
9743            .expect("invalid params");
9744        let resolver = crate::config::endpoint::DefaultResolver::new();
9745        let endpoint = resolver.resolve_endpoint(&params);
9746        let endpoint = endpoint
9747            .expect("Expected valid endpoint: https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com");
9748        assert_eq!(
9749            endpoint,
9750            ::aws_smithy_types::endpoint::Endpoint::builder()
9751                .url("https://myaccesspoint--usw2-az1--xa-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com")
9752                .auth_scheme(
9753                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9754                        .put("disableDoubleEncoding", true)
9755                        .put("signingName", "s3express".to_string())
9756                        .put("signingRegion", "us-west-2".to_string())
9757                )
9758                .property("backend", "S3Express".to_string())
9759                .build()
9760        );
9761    }
9762
9763    /// Data Plane with zone (9 char) and AP with dualstack
9764    #[test]
9765    fn test_377() {
9766        let params = crate::config::endpoint::Params::builder()
9767            .region("us-west-2".to_string())
9768            .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
9769            .use_fips(false)
9770            .use_dual_stack(true)
9771            .accelerate(false)
9772            .use_s3_express_control_endpoint(false)
9773            .build()
9774            .expect("invalid params");
9775        let resolver = crate::config::endpoint::DefaultResolver::new();
9776        let endpoint = resolver.resolve_endpoint(&params);
9777        let endpoint =
9778            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
9779        assert_eq!(
9780            endpoint,
9781            ::aws_smithy_types::endpoint::Endpoint::builder()
9782                .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
9783                .auth_scheme(
9784                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9785                        .put("disableDoubleEncoding", true)
9786                        .put("signingName", "s3express".to_string())
9787                        .put("signingRegion", "us-west-2".to_string())
9788                )
9789                .property("backend", "S3Express".to_string())
9790                .build()
9791        );
9792    }
9793
9794    /// Data Plane with zone (9 char) and FIPS with AP and dualstack
9795    #[test]
9796    fn test_378() {
9797        let params = crate::config::endpoint::Params::builder()
9798            .region("us-west-2".to_string())
9799            .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
9800            .use_fips(true)
9801            .use_dual_stack(true)
9802            .accelerate(false)
9803            .use_s3_express_control_endpoint(false)
9804            .build()
9805            .expect("invalid params");
9806        let resolver = crate::config::endpoint::DefaultResolver::new();
9807        let endpoint = resolver.resolve_endpoint(&params);
9808        let endpoint = endpoint
9809            .expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
9810        assert_eq!(
9811            endpoint,
9812            ::aws_smithy_types::endpoint::Endpoint::builder()
9813                .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
9814                .auth_scheme(
9815                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9816                        .put("disableDoubleEncoding", true)
9817                        .put("signingName", "s3express".to_string())
9818                        .put("signingRegion", "us-west-2".to_string())
9819                )
9820                .property("backend", "S3Express".to_string())
9821                .build()
9822        );
9823    }
9824
9825    /// Data Plane sigv4 auth with (9 char) zone and dualstack with AP
9826    #[test]
9827    fn test_379() {
9828        let params = crate::config::endpoint::Params::builder()
9829            .region("us-west-2".to_string())
9830            .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
9831            .use_fips(false)
9832            .use_dual_stack(true)
9833            .accelerate(false)
9834            .disable_s3_express_session_auth(true)
9835            .build()
9836            .expect("invalid params");
9837        let resolver = crate::config::endpoint::DefaultResolver::new();
9838        let endpoint = resolver.resolve_endpoint(&params);
9839        let endpoint =
9840            endpoint.expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com");
9841        assert_eq!(
9842            endpoint,
9843            ::aws_smithy_types::endpoint::Endpoint::builder()
9844                .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-usw2-az12.dualstack.us-west-2.amazonaws.com")
9845                .auth_scheme(
9846                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9847                        .put("disableDoubleEncoding", true)
9848                        .put("signingName", "s3express".to_string())
9849                        .put("signingRegion", "us-west-2".to_string())
9850                )
9851                .property("backend", "S3Express".to_string())
9852                .build()
9853        );
9854    }
9855
9856    /// Access Point sigv4 auth with (9 char) zone and FIPS with dualstack
9857    #[test]
9858    fn test_380() {
9859        let params = crate::config::endpoint::Params::builder()
9860            .region("us-west-2".to_string())
9861            .bucket("myaccesspoint--usw2-az12--xa-s3".to_string())
9862            .use_fips(true)
9863            .use_dual_stack(true)
9864            .accelerate(false)
9865            .disable_s3_express_session_auth(true)
9866            .build()
9867            .expect("invalid params");
9868        let resolver = crate::config::endpoint::DefaultResolver::new();
9869        let endpoint = resolver.resolve_endpoint(&params);
9870        let endpoint = endpoint
9871            .expect("Expected valid endpoint: https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com");
9872        assert_eq!(
9873            endpoint,
9874            ::aws_smithy_types::endpoint::Endpoint::builder()
9875                .url("https://myaccesspoint--usw2-az12--xa-s3.s3express-fips-usw2-az12.dualstack.us-west-2.amazonaws.com")
9876                .auth_scheme(
9877                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9878                        .put("disableDoubleEncoding", true)
9879                        .put("signingName", "s3express".to_string())
9880                        .put("signingRegion", "us-west-2".to_string())
9881                )
9882                .property("backend", "S3Express".to_string())
9883                .build()
9884        );
9885    }
9886
9887    /// Data Plane with zone (13 char) and AP with dualstack
9888    #[test]
9889    fn test_381() {
9890        let params = crate::config::endpoint::Params::builder()
9891            .region("us-west-2".to_string())
9892            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
9893            .use_fips(false)
9894            .use_dual_stack(true)
9895            .accelerate(false)
9896            .use_s3_express_control_endpoint(false)
9897            .build()
9898            .expect("invalid params");
9899        let resolver = crate::config::endpoint::DefaultResolver::new();
9900        let endpoint = resolver.resolve_endpoint(&params);
9901        let endpoint = endpoint
9902            .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
9903        assert_eq!(
9904            endpoint,
9905            ::aws_smithy_types::endpoint::Endpoint::builder()
9906                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
9907                .auth_scheme(
9908                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9909                        .put("disableDoubleEncoding", true)
9910                        .put("signingName", "s3express".to_string())
9911                        .put("signingRegion", "us-west-2".to_string())
9912                )
9913                .property("backend", "S3Express".to_string())
9914                .build()
9915        );
9916    }
9917
9918    /// Data Plane with zone (13 char) and AP with FIPS and dualstack
9919    #[test]
9920    fn test_382() {
9921        let params = crate::config::endpoint::Params::builder()
9922            .region("us-west-2".to_string())
9923            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
9924            .use_fips(true)
9925            .use_dual_stack(true)
9926            .accelerate(false)
9927            .use_s3_express_control_endpoint(false)
9928            .build()
9929            .expect("invalid params");
9930        let resolver = crate::config::endpoint::DefaultResolver::new();
9931        let endpoint = resolver.resolve_endpoint(&params);
9932        let endpoint = endpoint.expect(
9933            "Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com",
9934        );
9935        assert_eq!(
9936            endpoint,
9937            ::aws_smithy_types::endpoint::Endpoint::builder()
9938                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
9939                .auth_scheme(
9940                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
9941                        .put("disableDoubleEncoding", true)
9942                        .put("signingName", "s3express".to_string())
9943                        .put("signingRegion", "us-west-2".to_string())
9944                )
9945                .property("backend", "S3Express".to_string())
9946                .build()
9947        );
9948    }
9949
9950    /// Data Plane sigv4 auth with (13 char) zone with AP and dualstack
9951    #[test]
9952    fn test_383() {
9953        let params = crate::config::endpoint::Params::builder()
9954            .region("us-west-2".to_string())
9955            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
9956            .use_fips(false)
9957            .use_dual_stack(true)
9958            .accelerate(false)
9959            .disable_s3_express_session_auth(true)
9960            .build()
9961            .expect("invalid params");
9962        let resolver = crate::config::endpoint::DefaultResolver::new();
9963        let endpoint = resolver.resolve_endpoint(&params);
9964        let endpoint = endpoint
9965            .expect("Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com");
9966        assert_eq!(
9967            endpoint,
9968            ::aws_smithy_types::endpoint::Endpoint::builder()
9969                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
9970                .auth_scheme(
9971                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
9972                        .put("disableDoubleEncoding", true)
9973                        .put("signingName", "s3express".to_string())
9974                        .put("signingRegion", "us-west-2".to_string())
9975                )
9976                .property("backend", "S3Express".to_string())
9977                .build()
9978        );
9979    }
9980
9981    /// Data Plane sigv4 auth with (13 char) zone with AP and FIPS and dualstack
9982    #[test]
9983    fn test_384() {
9984        let params = crate::config::endpoint::Params::builder()
9985            .region("us-west-2".to_string())
9986            .bucket("myaccesspoint--test-zone-ab1--xa-s3".to_string())
9987            .use_fips(true)
9988            .use_dual_stack(true)
9989            .accelerate(false)
9990            .disable_s3_express_session_auth(true)
9991            .build()
9992            .expect("invalid params");
9993        let resolver = crate::config::endpoint::DefaultResolver::new();
9994        let endpoint = resolver.resolve_endpoint(&params);
9995        let endpoint = endpoint.expect(
9996            "Expected valid endpoint: https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com",
9997        );
9998        assert_eq!(
9999            endpoint,
10000            ::aws_smithy_types::endpoint::Endpoint::builder()
10001                .url("https://myaccesspoint--test-zone-ab1--xa-s3.s3express-fips-test-zone-ab1.dualstack.us-west-2.amazonaws.com")
10002                .auth_scheme(
10003                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
10004                        .put("disableDoubleEncoding", true)
10005                        .put("signingName", "s3express".to_string())
10006                        .put("signingRegion", "us-west-2".to_string())
10007                )
10008                .property("backend", "S3Express".to_string())
10009                .build()
10010        );
10011    }
10012
10013    /// Data Plane with (14 char) zone and AP with dualstack
10014    #[test]
10015    fn test_385() {
10016        let params = crate::config::endpoint::Params::builder()
10017            .region("us-west-2".to_string())
10018            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
10019            .use_fips(false)
10020            .use_dual_stack(true)
10021            .accelerate(false)
10022            .use_s3_express_control_endpoint(false)
10023            .build()
10024            .expect("invalid params");
10025        let resolver = crate::config::endpoint::DefaultResolver::new();
10026        let endpoint = resolver.resolve_endpoint(&params);
10027        let endpoint = endpoint.expect(
10028            "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
10029        );
10030        assert_eq!(
10031            endpoint,
10032            ::aws_smithy_types::endpoint::Endpoint::builder()
10033                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10034                .auth_scheme(
10035                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
10036                        .put("disableDoubleEncoding", true)
10037                        .put("signingName", "s3express".to_string())
10038                        .put("signingRegion", "us-west-2".to_string())
10039                )
10040                .property("backend", "S3Express".to_string())
10041                .build()
10042        );
10043    }
10044
10045    /// Data Plane with (14 char) zone and AP with FIPS and dualstack
10046    #[test]
10047    fn test_386() {
10048        let params = crate::config::endpoint::Params::builder()
10049            .region("us-west-2".to_string())
10050            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
10051            .use_fips(true)
10052            .use_dual_stack(true)
10053            .accelerate(false)
10054            .use_s3_express_control_endpoint(false)
10055            .build()
10056            .expect("invalid params");
10057        let resolver = crate::config::endpoint::DefaultResolver::new();
10058        let endpoint = resolver.resolve_endpoint(&params);
10059        let endpoint = endpoint.expect(
10060            "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
10061        );
10062        assert_eq!(
10063            endpoint,
10064            ::aws_smithy_types::endpoint::Endpoint::builder()
10065                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10066                .auth_scheme(
10067                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
10068                        .put("disableDoubleEncoding", true)
10069                        .put("signingName", "s3express".to_string())
10070                        .put("signingRegion", "us-west-2".to_string())
10071                )
10072                .property("backend", "S3Express".to_string())
10073                .build()
10074        );
10075    }
10076
10077    /// Data Plane sigv4 auth with (14 char) zone and AP with dualstack
10078    #[test]
10079    fn test_387() {
10080        let params = crate::config::endpoint::Params::builder()
10081            .region("us-west-2".to_string())
10082            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
10083            .use_fips(false)
10084            .use_dual_stack(true)
10085            .accelerate(false)
10086            .disable_s3_express_session_auth(true)
10087            .build()
10088            .expect("invalid params");
10089        let resolver = crate::config::endpoint::DefaultResolver::new();
10090        let endpoint = resolver.resolve_endpoint(&params);
10091        let endpoint = endpoint.expect(
10092            "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
10093        );
10094        assert_eq!(
10095            endpoint,
10096            ::aws_smithy_types::endpoint::Endpoint::builder()
10097                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10098                .auth_scheme(
10099                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
10100                        .put("disableDoubleEncoding", true)
10101                        .put("signingName", "s3express".to_string())
10102                        .put("signingRegion", "us-west-2".to_string())
10103                )
10104                .property("backend", "S3Express".to_string())
10105                .build()
10106        );
10107    }
10108
10109    /// Data Plane with (14 char) zone and AP with FIPS and dualstack
10110    #[test]
10111    fn test_388() {
10112        let params = crate::config::endpoint::Params::builder()
10113            .region("us-west-2".to_string())
10114            .bucket("myaccesspoint--test1-zone-ab1--xa-s3".to_string())
10115            .use_fips(true)
10116            .use_dual_stack(true)
10117            .accelerate(false)
10118            .disable_s3_express_session_auth(true)
10119            .build()
10120            .expect("invalid params");
10121        let resolver = crate::config::endpoint::DefaultResolver::new();
10122        let endpoint = resolver.resolve_endpoint(&params);
10123        let endpoint = endpoint.expect(
10124            "Expected valid endpoint: https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com",
10125        );
10126        assert_eq!(
10127            endpoint,
10128            ::aws_smithy_types::endpoint::Endpoint::builder()
10129                .url("https://myaccesspoint--test1-zone-ab1--xa-s3.s3express-fips-test1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10130                .auth_scheme(
10131                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
10132                        .put("disableDoubleEncoding", true)
10133                        .put("signingName", "s3express".to_string())
10134                        .put("signingRegion", "us-west-2".to_string())
10135                )
10136                .property("backend", "S3Express".to_string())
10137                .build()
10138        );
10139    }
10140
10141    /// Data Plane with (20 char) zone and AP with dualstack
10142    #[test]
10143    fn test_389() {
10144        let params = crate::config::endpoint::Params::builder()
10145            .region("us-west-2".to_string())
10146            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
10147            .use_fips(false)
10148            .use_dual_stack(true)
10149            .accelerate(false)
10150            .use_s3_express_control_endpoint(false)
10151            .build()
10152            .expect("invalid params");
10153        let resolver = crate::config::endpoint::DefaultResolver::new();
10154        let endpoint = resolver.resolve_endpoint(&params);
10155        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
10156        assert_eq!(
10157            endpoint,
10158            ::aws_smithy_types::endpoint::Endpoint::builder()
10159                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10160                .auth_scheme(
10161                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
10162                        .put("disableDoubleEncoding", true)
10163                        .put("signingName", "s3express".to_string())
10164                        .put("signingRegion", "us-west-2".to_string())
10165                )
10166                .property("backend", "S3Express".to_string())
10167                .build()
10168        );
10169    }
10170
10171    /// Data Plane with (20 char) zone and AP with FIPS and dualstack
10172    #[test]
10173    fn test_390() {
10174        let params = crate::config::endpoint::Params::builder()
10175            .region("us-west-2".to_string())
10176            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
10177            .use_fips(true)
10178            .use_dual_stack(true)
10179            .accelerate(false)
10180            .use_s3_express_control_endpoint(false)
10181            .build()
10182            .expect("invalid params");
10183        let resolver = crate::config::endpoint::DefaultResolver::new();
10184        let endpoint = resolver.resolve_endpoint(&params);
10185        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
10186        assert_eq!(
10187            endpoint,
10188            ::aws_smithy_types::endpoint::Endpoint::builder()
10189                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10190                .auth_scheme(
10191                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4-s3express", 3)
10192                        .put("disableDoubleEncoding", true)
10193                        .put("signingName", "s3express".to_string())
10194                        .put("signingRegion", "us-west-2".to_string())
10195                )
10196                .property("backend", "S3Express".to_string())
10197                .build()
10198        );
10199    }
10200
10201    /// Data plane AP with sigv4 and dualstack
10202    #[test]
10203    fn test_391() {
10204        let params = crate::config::endpoint::Params::builder()
10205            .region("us-west-2".to_string())
10206            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
10207            .use_fips(false)
10208            .use_dual_stack(true)
10209            .accelerate(false)
10210            .disable_s3_express_session_auth(true)
10211            .build()
10212            .expect("invalid params");
10213        let resolver = crate::config::endpoint::DefaultResolver::new();
10214        let endpoint = resolver.resolve_endpoint(&params);
10215        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
10216        assert_eq!(
10217            endpoint,
10218            ::aws_smithy_types::endpoint::Endpoint::builder()
10219                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10220                .auth_scheme(
10221                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
10222                        .put("disableDoubleEncoding", true)
10223                        .put("signingName", "s3express".to_string())
10224                        .put("signingRegion", "us-west-2".to_string())
10225                )
10226                .property("backend", "S3Express".to_string())
10227                .build()
10228        );
10229    }
10230
10231    /// Data plane AP sigv4 with fips and dualstack
10232    #[test]
10233    fn test_392() {
10234        let params = crate::config::endpoint::Params::builder()
10235            .region("us-west-2".to_string())
10236            .bucket("myaccesspoint--test1-long1-zone-ab1--xa-s3".to_string())
10237            .use_fips(true)
10238            .use_dual_stack(true)
10239            .accelerate(false)
10240            .disable_s3_express_session_auth(true)
10241            .build()
10242            .expect("invalid params");
10243        let resolver = crate::config::endpoint::DefaultResolver::new();
10244        let endpoint = resolver.resolve_endpoint(&params);
10245        let endpoint = endpoint.expect("Expected valid endpoint: https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com");
10246        assert_eq!(
10247            endpoint,
10248            ::aws_smithy_types::endpoint::Endpoint::builder()
10249                .url("https://myaccesspoint--test1-long1-zone-ab1--xa-s3.s3express-fips-test1-long1-zone-ab1.dualstack.us-west-2.amazonaws.com")
10250                .auth_scheme(
10251                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
10252                        .put("disableDoubleEncoding", true)
10253                        .put("signingName", "s3express".to_string())
10254                        .put("signingRegion", "us-west-2".to_string())
10255                )
10256                .property("backend", "S3Express".to_string())
10257                .build()
10258        );
10259    }
10260
10261    /// Control plane with dualstack and bucket
10262    #[test]
10263    fn test_393() {
10264        let params = crate::config::endpoint::Params::builder()
10265            .region("us-east-1".to_string())
10266            .bucket("mybucket--test-ab1--x-s3".to_string())
10267            .use_fips(false)
10268            .use_dual_stack(true)
10269            .accelerate(false)
10270            .use_s3_express_control_endpoint(true)
10271            .build()
10272            .expect("invalid params");
10273        let resolver = crate::config::endpoint::DefaultResolver::new();
10274        let endpoint = resolver.resolve_endpoint(&params);
10275        let endpoint =
10276            endpoint.expect("Expected valid endpoint: https://s3express-control.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3");
10277        assert_eq!(
10278            endpoint,
10279            ::aws_smithy_types::endpoint::Endpoint::builder()
10280                .url("https://s3express-control.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3")
10281                .auth_scheme(
10282                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 3)
10283                        .put("disableDoubleEncoding", true)
10284                        .put("signingName", "s3express".to_string())
10285                        .put("signingRegion", "us-east-1".to_string())
10286                )
10287                .property("backend", "S3Express".to_string())
10288                .build()
10289        );
10290    }
10291}
10292
10293/// Endpoint resolver trait specific to Amazon Simple Storage Service
10294pub trait ResolveEndpoint: ::std::marker::Send + ::std::marker::Sync + ::std::fmt::Debug {
10295    /// Resolve an endpoint with the given parameters
10296    fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a>;
10297
10298    /// Convert this service-specific resolver into a `SharedEndpointResolver`
10299    ///
10300    /// The resulting resolver will downcast `EndpointResolverParams` into `crate::config::endpoint::Params`.
10301    fn into_shared_resolver(self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver
10302    where
10303        Self: Sized + 'static,
10304    {
10305        ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
10306    }
10307}
10308
10309#[derive(Debug)]
10310struct DowncastParams<T>(T);
10311impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
10312where
10313    T: ResolveEndpoint,
10314{
10315    fn resolve_endpoint<'a>(
10316        &'a self,
10317        params: &'a ::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams,
10318    ) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
10319        let ep = match params.get::<crate::config::endpoint::Params>() {
10320            Some(params) => self.0.resolve_endpoint(params),
10321            None => ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(Err("params of expected type was not present".into())),
10322        };
10323        ep
10324    }
10325}
10326
10327#[derive(Debug)]
10328/// The default endpoint resolver.
10329pub struct DefaultResolver {
10330    partition_resolver: &'static crate::endpoint_lib::partition::PartitionResolver,
10331    endpoint_cache: ::arc_swap::ArcSwap<::std::option::Option<(Params, ::aws_smithy_types::endpoint::Endpoint)>>,
10332}
10333
10334impl Default for DefaultResolver {
10335    fn default() -> Self {
10336        Self::new()
10337    }
10338}
10339
10340impl DefaultResolver {
10341    /// Create a new DefaultResolver
10342    pub fn new() -> Self {
10343        Self {
10344            partition_resolver: &crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER,
10345            endpoint_cache: ::arc_swap::ArcSwap::from_pointee(None),
10346        }
10347    }
10348
10349    #[allow(
10350        unused_variables,
10351        unused_parens,
10352        clippy::double_parens,
10353        clippy::useless_conversion,
10354        clippy::bool_comparison,
10355        clippy::comparison_to_empty,
10356        clippy::needless_borrow,
10357        clippy::useless_asref,
10358        clippy::redundant_closure_call,
10359        clippy::clone_on_copy,
10360        clippy::single_char_add_str
10361    )]
10362    fn resolve_endpoint<'a>(
10363        &'a self,
10364        params: &'a crate::config::endpoint::Params,
10365    ) -> ::std::result::Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_runtime_api::box_error::BoxError> {
10366        let mut _diagnostic_collector = crate::endpoint_lib::diagnostic::DiagnosticCollector::new();
10367        #[allow(unused_mut)]
10368        let mut context = ConditionContext::default();
10369
10370        // Param bindings
10371        let bucket = &params.bucket;
10372        let region = &params.region;
10373        let use_fips = &params.use_fips;
10374        let use_dual_stack = &params.use_dual_stack;
10375        let endpoint = &params.endpoint;
10376        let force_path_style = &params.force_path_style;
10377        let accelerate = &params.accelerate;
10378        let use_global_endpoint = &params.use_global_endpoint;
10379        let use_object_lambda_endpoint = &params.use_object_lambda_endpoint;
10380        let key = &params.key;
10381        let prefix = &params.prefix;
10382        let copy_source = &params.copy_source;
10383        let disable_access_points = &params.disable_access_points;
10384        let disable_multi_region_access_points = &params.disable_multi_region_access_points;
10385        let use_arn_region = &params.use_arn_region;
10386        let use_s3_express_control_endpoint = &params.use_s3_express_control_endpoint;
10387        let disable_s3_express_session_auth = &params.disable_s3_express_session_auth;
10388
10389        let mut current_ref: i32 = 2;
10390        loop {
10391            match current_ref {
10392                ref_val if ref_val >= 100_000_000 => {
10393                    return match (ref_val - 100_000_000) as usize {
10394                        0 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
10395                            "No endpoint rule matched",
10396                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
10397                        1 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
10398                            "Accelerate cannot be used with FIPS".to_string(),
10399                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
10400                        2 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
10401                            "Cannot set dual-stack in combination with a custom endpoint.".to_string(),
10402                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
10403                        3 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
10404                            "A custom endpoint cannot be combined with FIPS".to_string(),
10405                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
10406                        4 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
10407                            "A custom endpoint cannot be combined with S3 Accelerate".to_string(),
10408                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
10409                        5 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
10410                            "Partition does not support FIPS".to_string(),
10411                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
10412                        6 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
10413                            "S3Express does not support S3 Accelerate.".to_string(),
10414                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
10415                        7 => {
10416                            let region = params.region.as_deref().unwrap_or_default();
10417                            let s3_e_auth = context.s3_e_auth.as_ref().expect("Guaranteed to have a value by earlier checks.");
10418                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
10419                            let uri_encoded_bucket = context
10420                                .uri_encoded_bucket
10421                                .as_ref()
10422                                .expect("Guaranteed to have a value by earlier checks.");
10423                            ::std::result::Result::Ok(
10424                                ::aws_smithy_types::endpoint::Endpoint::builder()
10425                                    .url({
10426                                        let mut out = String::new();
10427                                        #[allow(clippy::needless_borrow)]
10428                                        out.push_str(&url.scheme());
10429                                        out.push_str("://");
10430                                        #[allow(clippy::needless_borrow)]
10431                                        out.push_str(&url.authority());
10432                                        out.push_str("/");
10433                                        #[allow(clippy::needless_borrow)]
10434                                        out.push_str(&uri_encoded_bucket.as_ref());
10435                                        #[allow(clippy::needless_borrow)]
10436                                        out.push_str(&url.path());
10437                                        out
10438                                    })
10439                                    .property("backend", "S3Express".to_string())
10440                                    .auth_scheme(
10441                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity(s3_e_auth.to_owned(), 3)
10442                                            .put("disableDoubleEncoding", true)
10443                                            .put("signingName", "s3express")
10444                                            .put("signingRegion", region.as_ref()),
10445                                    )
10446                                    .build(),
10447                            )
10448                        }
10449                        8 => {
10450                            let bucket = params.bucket.as_deref().unwrap_or_default();
10451                            let region = params.region.as_deref().unwrap_or_default();
10452                            let s3_e_auth = context.s3_e_auth.as_ref().expect("Guaranteed to have a value by earlier checks.");
10453                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
10454                            ::std::result::Result::Ok(
10455                                ::aws_smithy_types::endpoint::Endpoint::builder()
10456                                    .url({
10457                                        let mut out = String::new();
10458                                        #[allow(clippy::needless_borrow)]
10459                                        out.push_str(&url.scheme());
10460                                        out.push_str("://");
10461                                        #[allow(clippy::needless_borrow)]
10462                                        out.push_str(&bucket.as_ref());
10463                                        out.push_str(".");
10464                                        #[allow(clippy::needless_borrow)]
10465                                        out.push_str(&url.authority());
10466                                        #[allow(clippy::needless_borrow)]
10467                                        out.push_str(&url.path());
10468                                        out
10469                                    })
10470                                    .property("backend", "S3Express".to_string())
10471                                    .auth_scheme(
10472                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity(s3_e_auth.to_owned(), 3)
10473                                            .put("disableDoubleEncoding", true)
10474                                            .put("signingName", "s3express")
10475                                            .put("signingRegion", region.as_ref()),
10476                                    )
10477                                    .build(),
10478                            )
10479                        }
10480                        9 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
10481                            "S3Express bucket name is not a valid virtual hostable name.".to_string(),
10482                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
10483                        10 => {
10484                            let region = params.region.as_deref().unwrap_or_default();
10485                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
10486                            let s3_e_ds = context.s3_e_ds.as_ref().expect("Guaranteed to have a value by earlier checks.");
10487                            let s3_e_fips = context.s3_e_fips.as_ref().expect("Guaranteed to have a value by earlier checks.");
10488                            let uri_encoded_bucket = context
10489                                .uri_encoded_bucket
10490                                .as_ref()
10491                                .expect("Guaranteed to have a value by earlier checks.");
10492                            ::std::result::Result::Ok(
10493                                ::aws_smithy_types::endpoint::Endpoint::builder()
10494                                    .url({
10495                                        let mut out = String::new();
10496                                        out.push_str("https://s3express-control");
10497                                        #[allow(clippy::needless_borrow)]
10498                                        out.push_str(&s3_e_fips.as_ref());
10499                                        #[allow(clippy::needless_borrow)]
10500                                        out.push_str(&s3_e_ds.as_ref());
10501                                        out.push_str(".");
10502                                        #[allow(clippy::needless_borrow)]
10503                                        out.push_str(&region.as_ref());
10504                                        out.push_str(".");
10505                                        #[allow(clippy::needless_borrow)]
10506                                        out.push_str(&partition_result.dns_suffix());
10507                                        out.push_str("/");
10508                                        #[allow(clippy::needless_borrow)]
10509                                        out.push_str(&uri_encoded_bucket.as_ref());
10510                                        out
10511                                    })
10512                                    .property("backend", "S3Express".to_string())
10513                                    .auth_scheme(
10514                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
10515                                            .put("disableDoubleEncoding", true)
10516                                            .put("signingName", "s3express")
10517                                            .put("signingRegion", region.as_ref()),
10518                                    )
10519                                    .build(),
10520                            )
10521                        }
10522                        11 => {
10523                            let bucket = params.bucket.as_deref().unwrap_or_default();
10524                            let region = params.region.as_deref().unwrap_or_default();
10525                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
10526                            let s3_e_ds = context.s3_e_ds.as_ref().expect("Guaranteed to have a value by earlier checks.");
10527                            let s3_e_fips = context.s3_e_fips.as_ref().expect("Guaranteed to have a value by earlier checks.");
10528                            let s3_e_auth = context.s3_e_auth.as_ref().expect("Guaranteed to have a value by earlier checks.");
10529                            let s3express_availability_zone_id = context
10530                                .s3express_availability_zone_id
10531                                .as_ref()
10532                                .expect("Guaranteed to have a value by earlier checks.");
10533                            ::std::result::Result::Ok(
10534                                ::aws_smithy_types::endpoint::Endpoint::builder()
10535                                    .url({
10536                                        let mut out = String::new();
10537                                        out.push_str("https://");
10538                                        #[allow(clippy::needless_borrow)]
10539                                        out.push_str(&bucket.as_ref());
10540                                        out.push_str(".s3express");
10541                                        #[allow(clippy::needless_borrow)]
10542                                        out.push_str(&s3_e_fips.as_ref());
10543                                        out.push_str("-");
10544                                        #[allow(clippy::needless_borrow)]
10545                                        out.push_str(&s3express_availability_zone_id.as_ref());
10546                                        #[allow(clippy::needless_borrow)]
10547                                        out.push_str(&s3_e_ds.as_ref());
10548                                        out.push_str(".");
10549                                        #[allow(clippy::needless_borrow)]
10550                                        out.push_str(&region.as_ref());
10551                                        out.push_str(".");
10552                                        #[allow(clippy::needless_borrow)]
10553                                        out.push_str(&partition_result.dns_suffix());
10554                                        out
10555                                    })
10556                                    .property("backend", "S3Express".to_string())
10557                                    .auth_scheme(
10558                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity(s3_e_auth.to_owned(), 3)
10559                                            .put("disableDoubleEncoding", true)
10560                                            .put("signingName", "s3express")
10561                                            .put("signingRegion", region.as_ref()),
10562                                    )
10563                                    .build(),
10564                            )
10565                        }
10566                        12 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
10567                            "Unrecognized S3Express bucket name format.".to_string(),
10568                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
10569                        13 => {
10570                            let region = params.region.as_deref().unwrap_or_default();
10571                            let s3_e_auth = context.s3_e_auth.as_ref().expect("Guaranteed to have a value by earlier checks.");
10572                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
10573                            ::std::result::Result::Ok(
10574                                ::aws_smithy_types::endpoint::Endpoint::builder()
10575                                    .url({
10576                                        let mut out = String::new();
10577                                        #[allow(clippy::needless_borrow)]
10578                                        out.push_str(&url.scheme());
10579                                        out.push_str("://");
10580                                        #[allow(clippy::needless_borrow)]
10581                                        out.push_str(&url.authority());
10582                                        #[allow(clippy::needless_borrow)]
10583                                        out.push_str(&url.path());
10584                                        out
10585                                    })
10586                                    .property("backend", "S3Express".to_string())
10587                                    .auth_scheme(
10588                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity(s3_e_auth.to_owned(), 3)
10589                                            .put("disableDoubleEncoding", true)
10590                                            .put("signingName", "s3express")
10591                                            .put("signingRegion", region.as_ref()),
10592                                    )
10593                                    .build(),
10594                            )
10595                        }
10596                        14 => {
10597                            let region = params.region.as_deref().unwrap_or_default();
10598                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
10599                            let s3_e_ds = context.s3_e_ds.as_ref().expect("Guaranteed to have a value by earlier checks.");
10600                            let s3_e_fips = context.s3_e_fips.as_ref().expect("Guaranteed to have a value by earlier checks.");
10601                            ::std::result::Result::Ok(
10602                                ::aws_smithy_types::endpoint::Endpoint::builder()
10603                                    .url({
10604                                        let mut out = String::new();
10605                                        out.push_str("https://s3express-control");
10606                                        #[allow(clippy::needless_borrow)]
10607                                        out.push_str(&s3_e_fips.as_ref());
10608                                        #[allow(clippy::needless_borrow)]
10609                                        out.push_str(&s3_e_ds.as_ref());
10610                                        out.push_str(".");
10611                                        #[allow(clippy::needless_borrow)]
10612                                        out.push_str(&region.as_ref());
10613                                        out.push_str(".");
10614                                        #[allow(clippy::needless_borrow)]
10615                                        out.push_str(&partition_result.dns_suffix());
10616                                        out
10617                                    })
10618                                    .property("backend", "S3Express".to_string())
10619                                    .auth_scheme(
10620                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
10621                                            .put("disableDoubleEncoding", true)
10622                                            .put("signingName", "s3express")
10623                                            .put("signingRegion", region.as_ref()),
10624                                    )
10625                                    .build(),
10626                            )
10627                        }
10628                        15 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
10629                            "Expected a endpoint to be specified but no endpoint was found".to_string(),
10630                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
10631                        16 => {
10632                            let bucket = params.bucket.as_deref().unwrap_or_default();
10633                            let region = params.region.as_deref().unwrap_or_default();
10634                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
10635                            ::std::result::Result::Ok(
10636                                ::aws_smithy_types::endpoint::Endpoint::builder()
10637                                    .url({
10638                                        let mut out = String::new();
10639                                        out.push_str("https://");
10640                                        #[allow(clippy::needless_borrow)]
10641                                        out.push_str(&bucket.as_ref());
10642                                        out.push_str(".ec2.");
10643                                        #[allow(clippy::needless_borrow)]
10644                                        out.push_str(&url.authority());
10645                                        out
10646                                    })
10647                                    .auth_scheme(
10648                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
10649                                            .put("disableDoubleEncoding", true)
10650                                            .put("signingName", "s3-outposts")
10651                                            .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
10652                                    )
10653                                    .auth_scheme(
10654                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
10655                                            .put("disableDoubleEncoding", true)
10656                                            .put("signingName", "s3-outposts")
10657                                            .put("signingRegion", region.as_ref()),
10658                                    )
10659                                    .build(),
10660                            )
10661                        }
10662                        17 => {
10663                            let bucket = params.bucket.as_deref().unwrap_or_default();
10664                            let region = params.region.as_deref().unwrap_or_default();
10665                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
10666                            ::std::result::Result::Ok(
10667                                ::aws_smithy_types::endpoint::Endpoint::builder()
10668                                    .url({
10669                                        let mut out = String::new();
10670                                        out.push_str("https://");
10671                                        #[allow(clippy::needless_borrow)]
10672                                        out.push_str(&bucket.as_ref());
10673                                        out.push_str(".ec2.s3-outposts.");
10674                                        #[allow(clippy::needless_borrow)]
10675                                        out.push_str(&region.as_ref());
10676                                        out.push_str(".");
10677                                        #[allow(clippy::needless_borrow)]
10678                                        out.push_str(&partition_result.dns_suffix());
10679                                        out
10680                                    })
10681                                    .auth_scheme(
10682                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
10683                                            .put("disableDoubleEncoding", true)
10684                                            .put("signingName", "s3-outposts")
10685                                            .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
10686                                    )
10687                                    .auth_scheme(
10688                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
10689                                            .put("disableDoubleEncoding", true)
10690                                            .put("signingName", "s3-outposts")
10691                                            .put("signingRegion", region.as_ref()),
10692                                    )
10693                                    .build(),
10694                            )
10695                        }
10696                        18 => {
10697                            let bucket = params.bucket.as_deref().unwrap_or_default();
10698                            let region = params.region.as_deref().unwrap_or_default();
10699                            let outpost_id_ssa_2 = context.outpost_id_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
10700                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
10701                            ::std::result::Result::Ok(
10702                                ::aws_smithy_types::endpoint::Endpoint::builder()
10703                                    .url({
10704                                        let mut out = String::new();
10705                                        out.push_str("https://");
10706                                        #[allow(clippy::needless_borrow)]
10707                                        out.push_str(&bucket.as_ref());
10708                                        out.push_str(".op-");
10709                                        #[allow(clippy::needless_borrow)]
10710                                        out.push_str(&outpost_id_ssa_2.as_ref());
10711                                        out.push_str(".");
10712                                        #[allow(clippy::needless_borrow)]
10713                                        out.push_str(&url.authority());
10714                                        out
10715                                    })
10716                                    .auth_scheme(
10717                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
10718                                            .put("disableDoubleEncoding", true)
10719                                            .put("signingName", "s3-outposts")
10720                                            .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
10721                                    )
10722                                    .auth_scheme(
10723                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
10724                                            .put("disableDoubleEncoding", true)
10725                                            .put("signingName", "s3-outposts")
10726                                            .put("signingRegion", region.as_ref()),
10727                                    )
10728                                    .build(),
10729                            )
10730                        }
10731                        19 => {
10732                            let bucket = params.bucket.as_deref().unwrap_or_default();
10733                            let region = params.region.as_deref().unwrap_or_default();
10734                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
10735                            let outpost_id_ssa_2 = context.outpost_id_ssa_2.as_ref().expect("Guaranteed to have a value by earlier checks.");
10736                            ::std::result::Result::Ok(
10737                                ::aws_smithy_types::endpoint::Endpoint::builder()
10738                                    .url({
10739                                        let mut out = String::new();
10740                                        out.push_str("https://");
10741                                        #[allow(clippy::needless_borrow)]
10742                                        out.push_str(&bucket.as_ref());
10743                                        out.push_str(".op-");
10744                                        #[allow(clippy::needless_borrow)]
10745                                        out.push_str(&outpost_id_ssa_2.as_ref());
10746                                        out.push_str(".s3-outposts.");
10747                                        #[allow(clippy::needless_borrow)]
10748                                        out.push_str(&region.as_ref());
10749                                        out.push_str(".");
10750                                        #[allow(clippy::needless_borrow)]
10751                                        out.push_str(&partition_result.dns_suffix());
10752                                        out
10753                                    })
10754                                    .auth_scheme(
10755                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
10756                                            .put("disableDoubleEncoding", true)
10757                                            .put("signingName", "s3-outposts")
10758                                            .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
10759                                    )
10760                                    .auth_scheme(
10761                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
10762                                            .put("disableDoubleEncoding", true)
10763                                            .put("signingName", "s3-outposts")
10764                                            .put("signingRegion", region.as_ref()),
10765                                    )
10766                                    .build(),
10767                            )
10768                        }
10769                        20 => {
10770                            let hardware_type = context.hardware_type.as_ref().expect("Guaranteed to have a value by earlier checks.");
10771                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
10772                                let mut out = String::new();
10773                                out.push_str("Unrecognized hardware type: \"Expected hardware type o or e but got ");
10774                                #[allow(clippy::needless_borrow)]
10775                                out.push_str(&hardware_type.as_ref());
10776                                out.push_str("\"");
10777                                out
10778                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
10779                        }
10780                        21 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
10781                            "Invalid Outposts Bucket alias - it must be a valid bucket name.".to_string(),
10782                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
10783                        22 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
10784                            "Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`.".to_string(),
10785                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
10786                        23 => {
10787                            let endpoint = params.endpoint.as_deref().unwrap_or_default();
10788                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
10789                                let mut out = String::new();
10790                                out.push_str("Custom endpoint `");
10791                                #[allow(clippy::needless_borrow)]
10792                                out.push_str(&endpoint.as_ref());
10793                                out.push_str("` was not a valid URI");
10794                                out
10795                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
10796                        }
10797                        24 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
10798                            "S3 Accelerate cannot be used in this region".to_string(),
10799                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
10800                        25 => {
10801                            let bucket = params.bucket.as_deref().unwrap_or_default();
10802                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
10803                            ::std::result::Result::Ok(
10804                                ::aws_smithy_types::endpoint::Endpoint::builder()
10805                                    .url({
10806                                        let mut out = String::new();
10807                                        out.push_str("https://");
10808                                        #[allow(clippy::needless_borrow)]
10809                                        out.push_str(&bucket.as_ref());
10810                                        out.push_str(".s3-fips.dualstack.us-east-1.");
10811                                        #[allow(clippy::needless_borrow)]
10812                                        out.push_str(&partition_result.dns_suffix());
10813                                        out
10814                                    })
10815                                    .auth_scheme(
10816                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
10817                                            .put("disableDoubleEncoding", true)
10818                                            .put("signingName", "s3")
10819                                            .put("signingRegion", "us-east-1"),
10820                                    )
10821                                    .build(),
10822                            )
10823                        }
10824                        26 => {
10825                            let bucket = params.bucket.as_deref().unwrap_or_default();
10826                            let region = params.region.as_deref().unwrap_or_default();
10827                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
10828                            ::std::result::Result::Ok(
10829                                ::aws_smithy_types::endpoint::Endpoint::builder()
10830                                    .url({
10831                                        let mut out = String::new();
10832                                        out.push_str("https://");
10833                                        #[allow(clippy::needless_borrow)]
10834                                        out.push_str(&bucket.as_ref());
10835                                        out.push_str(".s3-fips.dualstack.");
10836                                        #[allow(clippy::needless_borrow)]
10837                                        out.push_str(&region.as_ref());
10838                                        out.push_str(".");
10839                                        #[allow(clippy::needless_borrow)]
10840                                        out.push_str(&partition_result.dns_suffix());
10841                                        out
10842                                    })
10843                                    .auth_scheme(
10844                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
10845                                            .put("disableDoubleEncoding", true)
10846                                            .put("signingName", "s3")
10847                                            .put("signingRegion", region.as_ref()),
10848                                    )
10849                                    .build(),
10850                            )
10851                        }
10852                        27 => {
10853                            let bucket = params.bucket.as_deref().unwrap_or_default();
10854                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
10855                            ::std::result::Result::Ok(
10856                                ::aws_smithy_types::endpoint::Endpoint::builder()
10857                                    .url({
10858                                        let mut out = String::new();
10859                                        out.push_str("https://");
10860                                        #[allow(clippy::needless_borrow)]
10861                                        out.push_str(&bucket.as_ref());
10862                                        out.push_str(".s3-fips.us-east-1.");
10863                                        #[allow(clippy::needless_borrow)]
10864                                        out.push_str(&partition_result.dns_suffix());
10865                                        out
10866                                    })
10867                                    .auth_scheme(
10868                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
10869                                            .put("disableDoubleEncoding", true)
10870                                            .put("signingName", "s3")
10871                                            .put("signingRegion", "us-east-1"),
10872                                    )
10873                                    .build(),
10874                            )
10875                        }
10876                        28 => {
10877                            let bucket = params.bucket.as_deref().unwrap_or_default();
10878                            let region = params.region.as_deref().unwrap_or_default();
10879                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
10880                            ::std::result::Result::Ok(
10881                                ::aws_smithy_types::endpoint::Endpoint::builder()
10882                                    .url({
10883                                        let mut out = String::new();
10884                                        out.push_str("https://");
10885                                        #[allow(clippy::needless_borrow)]
10886                                        out.push_str(&bucket.as_ref());
10887                                        out.push_str(".s3-fips.");
10888                                        #[allow(clippy::needless_borrow)]
10889                                        out.push_str(&region.as_ref());
10890                                        out.push_str(".");
10891                                        #[allow(clippy::needless_borrow)]
10892                                        out.push_str(&partition_result.dns_suffix());
10893                                        out
10894                                    })
10895                                    .auth_scheme(
10896                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
10897                                            .put("disableDoubleEncoding", true)
10898                                            .put("signingName", "s3")
10899                                            .put("signingRegion", region.as_ref()),
10900                                    )
10901                                    .build(),
10902                            )
10903                        }
10904                        29 => {
10905                            let bucket = params.bucket.as_deref().unwrap_or_default();
10906                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
10907                            ::std::result::Result::Ok(
10908                                ::aws_smithy_types::endpoint::Endpoint::builder()
10909                                    .url({
10910                                        let mut out = String::new();
10911                                        out.push_str("https://");
10912                                        #[allow(clippy::needless_borrow)]
10913                                        out.push_str(&bucket.as_ref());
10914                                        out.push_str(".s3-accelerate.dualstack.us-east-1.");
10915                                        #[allow(clippy::needless_borrow)]
10916                                        out.push_str(&partition_result.dns_suffix());
10917                                        out
10918                                    })
10919                                    .auth_scheme(
10920                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
10921                                            .put("disableDoubleEncoding", true)
10922                                            .put("signingName", "s3")
10923                                            .put("signingRegion", "us-east-1"),
10924                                    )
10925                                    .build(),
10926                            )
10927                        }
10928                        30 => {
10929                            let bucket = params.bucket.as_deref().unwrap_or_default();
10930                            let region = params.region.as_deref().unwrap_or_default();
10931                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
10932                            ::std::result::Result::Ok(
10933                                ::aws_smithy_types::endpoint::Endpoint::builder()
10934                                    .url({
10935                                        let mut out = String::new();
10936                                        out.push_str("https://");
10937                                        #[allow(clippy::needless_borrow)]
10938                                        out.push_str(&bucket.as_ref());
10939                                        out.push_str(".s3-accelerate.dualstack.");
10940                                        #[allow(clippy::needless_borrow)]
10941                                        out.push_str(&partition_result.dns_suffix());
10942                                        out
10943                                    })
10944                                    .auth_scheme(
10945                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
10946                                            .put("disableDoubleEncoding", true)
10947                                            .put("signingName", "s3")
10948                                            .put("signingRegion", region.as_ref()),
10949                                    )
10950                                    .build(),
10951                            )
10952                        }
10953                        31 => {
10954                            let bucket = params.bucket.as_deref().unwrap_or_default();
10955                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
10956                            ::std::result::Result::Ok(
10957                                ::aws_smithy_types::endpoint::Endpoint::builder()
10958                                    .url({
10959                                        let mut out = String::new();
10960                                        out.push_str("https://");
10961                                        #[allow(clippy::needless_borrow)]
10962                                        out.push_str(&bucket.as_ref());
10963                                        out.push_str(".s3.dualstack.us-east-1.");
10964                                        #[allow(clippy::needless_borrow)]
10965                                        out.push_str(&partition_result.dns_suffix());
10966                                        out
10967                                    })
10968                                    .auth_scheme(
10969                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
10970                                            .put("disableDoubleEncoding", true)
10971                                            .put("signingName", "s3")
10972                                            .put("signingRegion", "us-east-1"),
10973                                    )
10974                                    .build(),
10975                            )
10976                        }
10977                        32 => {
10978                            let bucket = params.bucket.as_deref().unwrap_or_default();
10979                            let region = params.region.as_deref().unwrap_or_default();
10980                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
10981                            ::std::result::Result::Ok(
10982                                ::aws_smithy_types::endpoint::Endpoint::builder()
10983                                    .url({
10984                                        let mut out = String::new();
10985                                        out.push_str("https://");
10986                                        #[allow(clippy::needless_borrow)]
10987                                        out.push_str(&bucket.as_ref());
10988                                        out.push_str(".s3.dualstack.");
10989                                        #[allow(clippy::needless_borrow)]
10990                                        out.push_str(&region.as_ref());
10991                                        out.push_str(".");
10992                                        #[allow(clippy::needless_borrow)]
10993                                        out.push_str(&partition_result.dns_suffix());
10994                                        out
10995                                    })
10996                                    .auth_scheme(
10997                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
10998                                            .put("disableDoubleEncoding", true)
10999                                            .put("signingName", "s3")
11000                                            .put("signingRegion", region.as_ref()),
11001                                    )
11002                                    .build(),
11003                            )
11004                        }
11005                        33 => {
11006                            let bucket = params.bucket.as_deref().unwrap_or_default();
11007                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
11008                            ::std::result::Result::Ok(
11009                                ::aws_smithy_types::endpoint::Endpoint::builder()
11010                                    .url({
11011                                        let mut out = String::new();
11012                                        #[allow(clippy::needless_borrow)]
11013                                        out.push_str(&url.scheme());
11014                                        out.push_str("://");
11015                                        #[allow(clippy::needless_borrow)]
11016                                        out.push_str(&url.authority());
11017                                        #[allow(clippy::needless_borrow)]
11018                                        out.push_str(&url.normalized_path());
11019                                        #[allow(clippy::needless_borrow)]
11020                                        out.push_str(&bucket.as_ref());
11021                                        out
11022                                    })
11023                                    .auth_scheme(
11024                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11025                                            .put("disableDoubleEncoding", true)
11026                                            .put("signingName", "s3")
11027                                            .put("signingRegion", "us-east-1"),
11028                                    )
11029                                    .build(),
11030                            )
11031                        }
11032                        34 => {
11033                            let bucket = params.bucket.as_deref().unwrap_or_default();
11034                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
11035                            ::std::result::Result::Ok(
11036                                ::aws_smithy_types::endpoint::Endpoint::builder()
11037                                    .url({
11038                                        let mut out = String::new();
11039                                        #[allow(clippy::needless_borrow)]
11040                                        out.push_str(&url.scheme());
11041                                        out.push_str("://");
11042                                        #[allow(clippy::needless_borrow)]
11043                                        out.push_str(&bucket.as_ref());
11044                                        out.push_str(".");
11045                                        #[allow(clippy::needless_borrow)]
11046                                        out.push_str(&url.authority());
11047                                        #[allow(clippy::needless_borrow)]
11048                                        out.push_str(&url.path());
11049                                        out
11050                                    })
11051                                    .auth_scheme(
11052                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11053                                            .put("disableDoubleEncoding", true)
11054                                            .put("signingName", "s3")
11055                                            .put("signingRegion", "us-east-1"),
11056                                    )
11057                                    .build(),
11058                            )
11059                        }
11060                        35 => {
11061                            let bucket = params.bucket.as_deref().unwrap_or_default();
11062                            let region = params.region.as_deref().unwrap_or_default();
11063                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
11064                            ::std::result::Result::Ok(
11065                                ::aws_smithy_types::endpoint::Endpoint::builder()
11066                                    .url({
11067                                        let mut out = String::new();
11068                                        #[allow(clippy::needless_borrow)]
11069                                        out.push_str(&url.scheme());
11070                                        out.push_str("://");
11071                                        #[allow(clippy::needless_borrow)]
11072                                        out.push_str(&url.authority());
11073                                        #[allow(clippy::needless_borrow)]
11074                                        out.push_str(&url.normalized_path());
11075                                        #[allow(clippy::needless_borrow)]
11076                                        out.push_str(&bucket.as_ref());
11077                                        out
11078                                    })
11079                                    .auth_scheme(
11080                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11081                                            .put("disableDoubleEncoding", true)
11082                                            .put("signingName", "s3")
11083                                            .put("signingRegion", region.as_ref()),
11084                                    )
11085                                    .build(),
11086                            )
11087                        }
11088                        36 => {
11089                            let bucket = params.bucket.as_deref().unwrap_or_default();
11090                            let region = params.region.as_deref().unwrap_or_default();
11091                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
11092                            ::std::result::Result::Ok(
11093                                ::aws_smithy_types::endpoint::Endpoint::builder()
11094                                    .url({
11095                                        let mut out = String::new();
11096                                        #[allow(clippy::needless_borrow)]
11097                                        out.push_str(&url.scheme());
11098                                        out.push_str("://");
11099                                        #[allow(clippy::needless_borrow)]
11100                                        out.push_str(&bucket.as_ref());
11101                                        out.push_str(".");
11102                                        #[allow(clippy::needless_borrow)]
11103                                        out.push_str(&url.authority());
11104                                        #[allow(clippy::needless_borrow)]
11105                                        out.push_str(&url.path());
11106                                        out
11107                                    })
11108                                    .auth_scheme(
11109                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11110                                            .put("disableDoubleEncoding", true)
11111                                            .put("signingName", "s3")
11112                                            .put("signingRegion", region.as_ref()),
11113                                    )
11114                                    .build(),
11115                            )
11116                        }
11117                        37 => {
11118                            let bucket = params.bucket.as_deref().unwrap_or_default();
11119                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
11120                            ::std::result::Result::Ok(
11121                                ::aws_smithy_types::endpoint::Endpoint::builder()
11122                                    .url({
11123                                        let mut out = String::new();
11124                                        out.push_str("https://");
11125                                        #[allow(clippy::needless_borrow)]
11126                                        out.push_str(&bucket.as_ref());
11127                                        out.push_str(".s3-accelerate.");
11128                                        #[allow(clippy::needless_borrow)]
11129                                        out.push_str(&partition_result.dns_suffix());
11130                                        out
11131                                    })
11132                                    .auth_scheme(
11133                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11134                                            .put("disableDoubleEncoding", true)
11135                                            .put("signingName", "s3")
11136                                            .put("signingRegion", "us-east-1"),
11137                                    )
11138                                    .build(),
11139                            )
11140                        }
11141                        38 => {
11142                            let bucket = params.bucket.as_deref().unwrap_or_default();
11143                            let region = params.region.as_deref().unwrap_or_default();
11144                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
11145                            ::std::result::Result::Ok(
11146                                ::aws_smithy_types::endpoint::Endpoint::builder()
11147                                    .url({
11148                                        let mut out = String::new();
11149                                        out.push_str("https://");
11150                                        #[allow(clippy::needless_borrow)]
11151                                        out.push_str(&bucket.as_ref());
11152                                        out.push_str(".s3-accelerate.");
11153                                        #[allow(clippy::needless_borrow)]
11154                                        out.push_str(&partition_result.dns_suffix());
11155                                        out
11156                                    })
11157                                    .auth_scheme(
11158                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11159                                            .put("disableDoubleEncoding", true)
11160                                            .put("signingName", "s3")
11161                                            .put("signingRegion", region.as_ref()),
11162                                    )
11163                                    .build(),
11164                            )
11165                        }
11166                        39 => {
11167                            let bucket = params.bucket.as_deref().unwrap_or_default();
11168                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
11169                            ::std::result::Result::Ok(
11170                                ::aws_smithy_types::endpoint::Endpoint::builder()
11171                                    .url({
11172                                        let mut out = String::new();
11173                                        out.push_str("https://");
11174                                        #[allow(clippy::needless_borrow)]
11175                                        out.push_str(&bucket.as_ref());
11176                                        out.push_str(".s3.");
11177                                        #[allow(clippy::needless_borrow)]
11178                                        out.push_str(&partition_result.dns_suffix());
11179                                        out
11180                                    })
11181                                    .auth_scheme(
11182                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11183                                            .put("disableDoubleEncoding", true)
11184                                            .put("signingName", "s3")
11185                                            .put("signingRegion", "us-east-1"),
11186                                    )
11187                                    .build(),
11188                            )
11189                        }
11190                        40 => {
11191                            let bucket = params.bucket.as_deref().unwrap_or_default();
11192                            let region = params.region.as_deref().unwrap_or_default();
11193                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
11194                            ::std::result::Result::Ok(
11195                                ::aws_smithy_types::endpoint::Endpoint::builder()
11196                                    .url({
11197                                        let mut out = String::new();
11198                                        out.push_str("https://");
11199                                        #[allow(clippy::needless_borrow)]
11200                                        out.push_str(&bucket.as_ref());
11201                                        out.push_str(".s3.");
11202                                        #[allow(clippy::needless_borrow)]
11203                                        out.push_str(&partition_result.dns_suffix());
11204                                        out
11205                                    })
11206                                    .auth_scheme(
11207                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11208                                            .put("disableDoubleEncoding", true)
11209                                            .put("signingName", "s3")
11210                                            .put("signingRegion", region.as_ref()),
11211                                    )
11212                                    .build(),
11213                            )
11214                        }
11215                        41 => {
11216                            let bucket = params.bucket.as_deref().unwrap_or_default();
11217                            let region = params.region.as_deref().unwrap_or_default();
11218                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
11219                            ::std::result::Result::Ok(
11220                                ::aws_smithy_types::endpoint::Endpoint::builder()
11221                                    .url({
11222                                        let mut out = String::new();
11223                                        out.push_str("https://");
11224                                        #[allow(clippy::needless_borrow)]
11225                                        out.push_str(&bucket.as_ref());
11226                                        out.push_str(".s3.");
11227                                        #[allow(clippy::needless_borrow)]
11228                                        out.push_str(&region.as_ref());
11229                                        out.push_str(".");
11230                                        #[allow(clippy::needless_borrow)]
11231                                        out.push_str(&partition_result.dns_suffix());
11232                                        out
11233                                    })
11234                                    .auth_scheme(
11235                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11236                                            .put("disableDoubleEncoding", true)
11237                                            .put("signingName", "s3")
11238                                            .put("signingRegion", region.as_ref()),
11239                                    )
11240                                    .build(),
11241                            )
11242                        }
11243                        42 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11244                            "Invalid region: region was not a valid DNS name.".to_string(),
11245                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11246                        43 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11247                            "S3 Object Lambda does not support Dual-stack".to_string(),
11248                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11249                        44 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11250                            "S3 Object Lambda does not support S3 Accelerate".to_string(),
11251                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11252                        45 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11253                            "Access points are not supported for this operation".to_string(),
11254                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11255                        46 => {
11256                            let region = params.region.as_deref().unwrap_or_default();
11257                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11258                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
11259                                let mut out = String::new();
11260                                out.push_str("Invalid configuration: region from ARN `");
11261                                #[allow(clippy::needless_borrow)]
11262                                out.push_str(&bucket_arn.region());
11263                                out.push_str("` does not match client region `");
11264                                #[allow(clippy::needless_borrow)]
11265                                out.push_str(&region.as_ref());
11266                                out.push_str("` and UseArnRegion is `false`");
11267                                out
11268                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
11269                        }
11270                        47 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11271                            "Invalid ARN: Missing account id".to_string(),
11272                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11273                        48 => {
11274                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
11275                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11276                            let access_point_name_ssa_1 = context
11277                                .access_point_name_ssa_1
11278                                .as_ref()
11279                                .expect("Guaranteed to have a value by earlier checks.");
11280                            ::std::result::Result::Ok(
11281                                ::aws_smithy_types::endpoint::Endpoint::builder()
11282                                    .url({
11283                                        let mut out = String::new();
11284                                        #[allow(clippy::needless_borrow)]
11285                                        out.push_str(&url.scheme());
11286                                        out.push_str("://");
11287                                        #[allow(clippy::needless_borrow)]
11288                                        out.push_str(&access_point_name_ssa_1.as_ref());
11289                                        out.push_str("-");
11290                                        #[allow(clippy::needless_borrow)]
11291                                        out.push_str(&bucket_arn.account_id());
11292                                        out.push_str(".");
11293                                        #[allow(clippy::needless_borrow)]
11294                                        out.push_str(&url.authority());
11295                                        #[allow(clippy::needless_borrow)]
11296                                        out.push_str(&url.path());
11297                                        out
11298                                    })
11299                                    .auth_scheme(
11300                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11301                                            .put("disableDoubleEncoding", true)
11302                                            .put("signingName", "s3-object-lambda")
11303                                            .put("signingRegion", bucket_arn.region()),
11304                                    )
11305                                    .build(),
11306                            )
11307                        }
11308                        49 => {
11309                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11310                            let access_point_name_ssa_1 = context
11311                                .access_point_name_ssa_1
11312                                .as_ref()
11313                                .expect("Guaranteed to have a value by earlier checks.");
11314                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
11315                            ::std::result::Result::Ok(
11316                                ::aws_smithy_types::endpoint::Endpoint::builder()
11317                                    .url({
11318                                        let mut out = String::new();
11319                                        out.push_str("https://");
11320                                        #[allow(clippy::needless_borrow)]
11321                                        out.push_str(&access_point_name_ssa_1.as_ref());
11322                                        out.push_str("-");
11323                                        #[allow(clippy::needless_borrow)]
11324                                        out.push_str(&bucket_arn.account_id());
11325                                        out.push_str(".s3-object-lambda-fips.");
11326                                        #[allow(clippy::needless_borrow)]
11327                                        out.push_str(&bucket_arn.region());
11328                                        out.push_str(".");
11329                                        #[allow(clippy::needless_borrow)]
11330                                        out.push_str(&bucket_partition.dns_suffix());
11331                                        out
11332                                    })
11333                                    .auth_scheme(
11334                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11335                                            .put("disableDoubleEncoding", true)
11336                                            .put("signingName", "s3-object-lambda")
11337                                            .put("signingRegion", bucket_arn.region()),
11338                                    )
11339                                    .build(),
11340                            )
11341                        }
11342                        50 => {
11343                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11344                            let access_point_name_ssa_1 = context
11345                                .access_point_name_ssa_1
11346                                .as_ref()
11347                                .expect("Guaranteed to have a value by earlier checks.");
11348                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
11349                            ::std::result::Result::Ok(
11350                                ::aws_smithy_types::endpoint::Endpoint::builder()
11351                                    .url({
11352                                        let mut out = String::new();
11353                                        out.push_str("https://");
11354                                        #[allow(clippy::needless_borrow)]
11355                                        out.push_str(&access_point_name_ssa_1.as_ref());
11356                                        out.push_str("-");
11357                                        #[allow(clippy::needless_borrow)]
11358                                        out.push_str(&bucket_arn.account_id());
11359                                        out.push_str(".s3-object-lambda.");
11360                                        #[allow(clippy::needless_borrow)]
11361                                        out.push_str(&bucket_arn.region());
11362                                        out.push_str(".");
11363                                        #[allow(clippy::needless_borrow)]
11364                                        out.push_str(&bucket_partition.dns_suffix());
11365                                        out
11366                                    })
11367                                    .auth_scheme(
11368                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11369                                            .put("disableDoubleEncoding", true)
11370                                            .put("signingName", "s3-object-lambda")
11371                                            .put("signingRegion", bucket_arn.region()),
11372                                    )
11373                                    .build(),
11374                            )
11375                        }
11376                        51 => {
11377                            let access_point_name_ssa_1 = context
11378                                .access_point_name_ssa_1
11379                                .as_ref()
11380                                .expect("Guaranteed to have a value by earlier checks.");
11381                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
11382                                let mut out = String::new();
11383                                out.push_str("Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `");
11384                                #[allow(clippy::needless_borrow)]
11385                                out.push_str(&access_point_name_ssa_1.as_ref());
11386                                out.push_str("`");
11387                                out
11388                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
11389                        }
11390                        52 => {
11391                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11392                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
11393                                let mut out = String::new();
11394                                out.push_str("Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `");
11395                                #[allow(clippy::needless_borrow)]
11396                                out.push_str(&bucket_arn.account_id());
11397                                out.push_str("`");
11398                                out
11399                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
11400                        }
11401                        53 => {
11402                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11403                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
11404                                let mut out = String::new();
11405                                out.push_str("Invalid region in ARN: `");
11406                                #[allow(clippy::needless_borrow)]
11407                                out.push_str(&bucket_arn.region());
11408                                out.push_str("` (invalid DNS name)");
11409                                out
11410                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
11411                        }
11412                        54 => {
11413                            let bucket = params.bucket.as_deref().unwrap_or_default();
11414                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
11415                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
11416                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
11417                                let mut out = String::new();
11418                                out.push_str("Client was configured for partition `");
11419                                #[allow(clippy::needless_borrow)]
11420                                out.push_str(&partition_result.name());
11421                                out.push_str("` but ARN (`");
11422                                #[allow(clippy::needless_borrow)]
11423                                out.push_str(&bucket.as_ref());
11424                                out.push_str("`) has `");
11425                                #[allow(clippy::needless_borrow)]
11426                                out.push_str(&bucket_partition.name());
11427                                out.push_str("`");
11428                                out
11429                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
11430                        }
11431                        55 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11432                            "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`.".to_string(),
11433                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11434                        56 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11435                            "Invalid ARN: bucket ARN is missing a region".to_string(),
11436                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11437                        57 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11438                            "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided".to_string(),
11439                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11440                        58 => {
11441                            let arn_type = context.arn_type.as_ref().expect("Guaranteed to have a value by earlier checks.");
11442                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
11443                                let mut out = String::new();
11444                                out.push_str("Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `");
11445                                #[allow(clippy::needless_borrow)]
11446                                out.push_str(&arn_type.as_ref());
11447                                out.push_str("`");
11448                                out
11449                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
11450                        }
11451                        59 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11452                            "Access Points do not support S3 Accelerate".to_string(),
11453                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11454                        60 => {
11455                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11456                            let access_point_name_ssa_1 = context
11457                                .access_point_name_ssa_1
11458                                .as_ref()
11459                                .expect("Guaranteed to have a value by earlier checks.");
11460                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
11461                            ::std::result::Result::Ok(
11462                                ::aws_smithy_types::endpoint::Endpoint::builder()
11463                                    .url({
11464                                        let mut out = String::new();
11465                                        out.push_str("https://");
11466                                        #[allow(clippy::needless_borrow)]
11467                                        out.push_str(&access_point_name_ssa_1.as_ref());
11468                                        out.push_str("-");
11469                                        #[allow(clippy::needless_borrow)]
11470                                        out.push_str(&bucket_arn.account_id());
11471                                        out.push_str(".s3-accesspoint-fips.dualstack.");
11472                                        #[allow(clippy::needless_borrow)]
11473                                        out.push_str(&bucket_arn.region());
11474                                        out.push_str(".");
11475                                        #[allow(clippy::needless_borrow)]
11476                                        out.push_str(&bucket_partition.dns_suffix());
11477                                        out
11478                                    })
11479                                    .auth_scheme(
11480                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11481                                            .put("disableDoubleEncoding", true)
11482                                            .put("signingName", "s3")
11483                                            .put("signingRegion", bucket_arn.region()),
11484                                    )
11485                                    .build(),
11486                            )
11487                        }
11488                        61 => {
11489                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11490                            let access_point_name_ssa_1 = context
11491                                .access_point_name_ssa_1
11492                                .as_ref()
11493                                .expect("Guaranteed to have a value by earlier checks.");
11494                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
11495                            ::std::result::Result::Ok(
11496                                ::aws_smithy_types::endpoint::Endpoint::builder()
11497                                    .url({
11498                                        let mut out = String::new();
11499                                        out.push_str("https://");
11500                                        #[allow(clippy::needless_borrow)]
11501                                        out.push_str(&access_point_name_ssa_1.as_ref());
11502                                        out.push_str("-");
11503                                        #[allow(clippy::needless_borrow)]
11504                                        out.push_str(&bucket_arn.account_id());
11505                                        out.push_str(".s3-accesspoint-fips.");
11506                                        #[allow(clippy::needless_borrow)]
11507                                        out.push_str(&bucket_arn.region());
11508                                        out.push_str(".");
11509                                        #[allow(clippy::needless_borrow)]
11510                                        out.push_str(&bucket_partition.dns_suffix());
11511                                        out
11512                                    })
11513                                    .auth_scheme(
11514                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11515                                            .put("disableDoubleEncoding", true)
11516                                            .put("signingName", "s3")
11517                                            .put("signingRegion", bucket_arn.region()),
11518                                    )
11519                                    .build(),
11520                            )
11521                        }
11522                        62 => {
11523                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11524                            let access_point_name_ssa_1 = context
11525                                .access_point_name_ssa_1
11526                                .as_ref()
11527                                .expect("Guaranteed to have a value by earlier checks.");
11528                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
11529                            ::std::result::Result::Ok(
11530                                ::aws_smithy_types::endpoint::Endpoint::builder()
11531                                    .url({
11532                                        let mut out = String::new();
11533                                        out.push_str("https://");
11534                                        #[allow(clippy::needless_borrow)]
11535                                        out.push_str(&access_point_name_ssa_1.as_ref());
11536                                        out.push_str("-");
11537                                        #[allow(clippy::needless_borrow)]
11538                                        out.push_str(&bucket_arn.account_id());
11539                                        out.push_str(".s3-accesspoint.dualstack.");
11540                                        #[allow(clippy::needless_borrow)]
11541                                        out.push_str(&bucket_arn.region());
11542                                        out.push_str(".");
11543                                        #[allow(clippy::needless_borrow)]
11544                                        out.push_str(&bucket_partition.dns_suffix());
11545                                        out
11546                                    })
11547                                    .auth_scheme(
11548                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11549                                            .put("disableDoubleEncoding", true)
11550                                            .put("signingName", "s3")
11551                                            .put("signingRegion", bucket_arn.region()),
11552                                    )
11553                                    .build(),
11554                            )
11555                        }
11556                        63 => {
11557                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
11558                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11559                            let access_point_name_ssa_1 = context
11560                                .access_point_name_ssa_1
11561                                .as_ref()
11562                                .expect("Guaranteed to have a value by earlier checks.");
11563                            ::std::result::Result::Ok(
11564                                ::aws_smithy_types::endpoint::Endpoint::builder()
11565                                    .url({
11566                                        let mut out = String::new();
11567                                        #[allow(clippy::needless_borrow)]
11568                                        out.push_str(&url.scheme());
11569                                        out.push_str("://");
11570                                        #[allow(clippy::needless_borrow)]
11571                                        out.push_str(&access_point_name_ssa_1.as_ref());
11572                                        out.push_str("-");
11573                                        #[allow(clippy::needless_borrow)]
11574                                        out.push_str(&bucket_arn.account_id());
11575                                        out.push_str(".");
11576                                        #[allow(clippy::needless_borrow)]
11577                                        out.push_str(&url.authority());
11578                                        #[allow(clippy::needless_borrow)]
11579                                        out.push_str(&url.path());
11580                                        out
11581                                    })
11582                                    .auth_scheme(
11583                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11584                                            .put("disableDoubleEncoding", true)
11585                                            .put("signingName", "s3")
11586                                            .put("signingRegion", bucket_arn.region()),
11587                                    )
11588                                    .build(),
11589                            )
11590                        }
11591                        64 => {
11592                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11593                            let access_point_name_ssa_1 = context
11594                                .access_point_name_ssa_1
11595                                .as_ref()
11596                                .expect("Guaranteed to have a value by earlier checks.");
11597                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
11598                            ::std::result::Result::Ok(
11599                                ::aws_smithy_types::endpoint::Endpoint::builder()
11600                                    .url({
11601                                        let mut out = String::new();
11602                                        out.push_str("https://");
11603                                        #[allow(clippy::needless_borrow)]
11604                                        out.push_str(&access_point_name_ssa_1.as_ref());
11605                                        out.push_str("-");
11606                                        #[allow(clippy::needless_borrow)]
11607                                        out.push_str(&bucket_arn.account_id());
11608                                        out.push_str(".s3-accesspoint.");
11609                                        #[allow(clippy::needless_borrow)]
11610                                        out.push_str(&bucket_arn.region());
11611                                        out.push_str(".");
11612                                        #[allow(clippy::needless_borrow)]
11613                                        out.push_str(&bucket_partition.dns_suffix());
11614                                        out
11615                                    })
11616                                    .auth_scheme(
11617                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11618                                            .put("disableDoubleEncoding", true)
11619                                            .put("signingName", "s3")
11620                                            .put("signingRegion", bucket_arn.region()),
11621                                    )
11622                                    .build(),
11623                            )
11624                        }
11625                        65 => {
11626                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11627                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
11628                                let mut out = String::new();
11629                                out.push_str("Invalid ARN: The ARN was not for the S3 service, found: ");
11630                                #[allow(clippy::needless_borrow)]
11631                                out.push_str(&bucket_arn.service());
11632                                out
11633                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
11634                        }
11635                        66 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11636                            "S3 MRAP does not support dual-stack".to_string(),
11637                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11638                        67 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11639                            "S3 MRAP does not support FIPS".to_string(),
11640                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11641                        68 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11642                            "S3 MRAP does not support S3 Accelerate".to_string(),
11643                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11644                        69 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11645                            "Invalid configuration: Multi-Region Access Point ARNs are disabled.".to_string(),
11646                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11647                        70 => {
11648                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
11649                            let access_point_name_ssa_1 = context
11650                                .access_point_name_ssa_1
11651                                .as_ref()
11652                                .expect("Guaranteed to have a value by earlier checks.");
11653                            ::std::result::Result::Ok(
11654                                ::aws_smithy_types::endpoint::Endpoint::builder()
11655                                    .url({
11656                                        let mut out = String::new();
11657                                        out.push_str("https://");
11658                                        #[allow(clippy::needless_borrow)]
11659                                        out.push_str(&access_point_name_ssa_1.as_ref());
11660                                        out.push_str(".accesspoint.s3-global.");
11661                                        #[allow(clippy::needless_borrow)]
11662                                        out.push_str(&partition_result.dns_suffix());
11663                                        out
11664                                    })
11665                                    .auth_scheme(
11666                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
11667                                            .put("disableDoubleEncoding", true)
11668                                            .put("signingName", "s3")
11669                                            .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
11670                                    )
11671                                    .build(),
11672                            )
11673                        }
11674                        71 => {
11675                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
11676                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11677                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
11678                                let mut out = String::new();
11679                                out.push_str("Client was configured for partition `");
11680                                #[allow(clippy::needless_borrow)]
11681                                out.push_str(&partition_result.name());
11682                                out.push_str("` but bucket referred to partition `");
11683                                #[allow(clippy::needless_borrow)]
11684                                out.push_str(&bucket_arn.partition());
11685                                out.push_str("`");
11686                                out
11687                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
11688                        }
11689                        72 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11690                            "Invalid Access Point Name".to_string(),
11691                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11692                        73 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11693                            "S3 Outposts does not support Dual-stack".to_string(),
11694                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11695                        74 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11696                            "S3 Outposts does not support FIPS".to_string(),
11697                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11698                        75 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11699                            "S3 Outposts does not support S3 Accelerate".to_string(),
11700                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11701                        76 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11702                            "Invalid Arn: Outpost Access Point ARN contains sub resources".to_string(),
11703                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11704                        77 => {
11705                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
11706                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11707                            let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
11708                            let access_point_name_ssa_2 = context
11709                                .access_point_name_ssa_2
11710                                .as_ref()
11711                                .expect("Guaranteed to have a value by earlier checks.");
11712                            ::std::result::Result::Ok(
11713                                ::aws_smithy_types::endpoint::Endpoint::builder()
11714                                    .url({
11715                                        let mut out = String::new();
11716                                        out.push_str("https://");
11717                                        #[allow(clippy::needless_borrow)]
11718                                        out.push_str(&access_point_name_ssa_2.as_ref());
11719                                        out.push_str("-");
11720                                        #[allow(clippy::needless_borrow)]
11721                                        out.push_str(&bucket_arn.account_id());
11722                                        out.push_str(".");
11723                                        #[allow(clippy::needless_borrow)]
11724                                        out.push_str(&outpost_id_ssa_1.as_ref());
11725                                        out.push_str(".");
11726                                        #[allow(clippy::needless_borrow)]
11727                                        out.push_str(&url.authority());
11728                                        out
11729                                    })
11730                                    .auth_scheme(
11731                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
11732                                            .put("disableDoubleEncoding", true)
11733                                            .put("signingName", "s3-outposts")
11734                                            .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
11735                                    )
11736                                    .auth_scheme(
11737                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11738                                            .put("disableDoubleEncoding", true)
11739                                            .put("signingName", "s3-outposts")
11740                                            .put("signingRegion", bucket_arn.region()),
11741                                    )
11742                                    .build(),
11743                            )
11744                        }
11745                        78 => {
11746                            let bucket_arn = context.bucket_arn.as_ref().expect("Guaranteed to have a value by earlier checks.");
11747                            let bucket_partition = context.bucket_partition.as_ref().expect("Guaranteed to have a value by earlier checks.");
11748                            let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
11749                            let access_point_name_ssa_2 = context
11750                                .access_point_name_ssa_2
11751                                .as_ref()
11752                                .expect("Guaranteed to have a value by earlier checks.");
11753                            ::std::result::Result::Ok(
11754                                ::aws_smithy_types::endpoint::Endpoint::builder()
11755                                    .url({
11756                                        let mut out = String::new();
11757                                        out.push_str("https://");
11758                                        #[allow(clippy::needless_borrow)]
11759                                        out.push_str(&access_point_name_ssa_2.as_ref());
11760                                        out.push_str("-");
11761                                        #[allow(clippy::needless_borrow)]
11762                                        out.push_str(&bucket_arn.account_id());
11763                                        out.push_str(".");
11764                                        #[allow(clippy::needless_borrow)]
11765                                        out.push_str(&outpost_id_ssa_1.as_ref());
11766                                        out.push_str(".s3-outposts.");
11767                                        #[allow(clippy::needless_borrow)]
11768                                        out.push_str(&bucket_arn.region());
11769                                        out.push_str(".");
11770                                        #[allow(clippy::needless_borrow)]
11771                                        out.push_str(&bucket_partition.dns_suffix());
11772                                        out
11773                                    })
11774                                    .auth_scheme(
11775                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4a".to_string(), 3)
11776                                            .put("disableDoubleEncoding", true)
11777                                            .put("signingName", "s3-outposts")
11778                                            .put("signingRegionSet", vec![::aws_smithy_types::Document::from("*".to_string())]),
11779                                    )
11780                                    .auth_scheme(
11781                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11782                                            .put("disableDoubleEncoding", true)
11783                                            .put("signingName", "s3-outposts")
11784                                            .put("signingRegion", bucket_arn.region()),
11785                                    )
11786                                    .build(),
11787                            )
11788                        }
11789                        79 => {
11790                            let access_point_name_ssa_2 = context
11791                                .access_point_name_ssa_2
11792                                .as_ref()
11793                                .expect("Guaranteed to have a value by earlier checks.");
11794                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
11795                                let mut out = String::new();
11796                                out.push_str("Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `");
11797                                #[allow(clippy::needless_borrow)]
11798                                out.push_str(&access_point_name_ssa_2.as_ref());
11799                                out.push_str("`");
11800                                out
11801                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
11802                        }
11803                        80 => {
11804                            let outpost_type = context.outpost_type.as_ref().expect("Guaranteed to have a value by earlier checks.");
11805                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
11806                                let mut out = String::new();
11807                                out.push_str("Expected an outpost type `accesspoint`, found ");
11808                                #[allow(clippy::needless_borrow)]
11809                                out.push_str(&outpost_type.as_ref());
11810                                out
11811                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
11812                        }
11813                        81 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11814                            "Invalid ARN: expected an access point name".to_string(),
11815                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11816                        82 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11817                            "Invalid ARN: Expected a 4-component resource".to_string(),
11818                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11819                        83 => {
11820                            let outpost_id_ssa_1 = context.outpost_id_ssa_1.as_ref().expect("Guaranteed to have a value by earlier checks.");
11821                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
11822                                let mut out = String::new();
11823                                out.push_str("Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `");
11824                                #[allow(clippy::needless_borrow)]
11825                                out.push_str(&outpost_id_ssa_1.as_ref());
11826                                out.push_str("`");
11827                                out
11828                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
11829                        }
11830                        84 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11831                            "Invalid ARN: The Outpost Id was not set".to_string(),
11832                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11833                        85 => {
11834                            let bucket = params.bucket.as_deref().unwrap_or_default();
11835                            let arn_type = context.arn_type.as_ref().expect("Guaranteed to have a value by earlier checks.");
11836                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
11837                                let mut out = String::new();
11838                                out.push_str("Invalid ARN: Unrecognized format: ");
11839                                #[allow(clippy::needless_borrow)]
11840                                out.push_str(&bucket.as_ref());
11841                                out.push_str(" (type: ");
11842                                #[allow(clippy::needless_borrow)]
11843                                out.push_str(&arn_type.as_ref());
11844                                out.push_str(")");
11845                                out
11846                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
11847                        }
11848                        86 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11849                            "Invalid ARN: No ARN type specified".to_string(),
11850                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11851                        87 => {
11852                            let bucket = params.bucket.as_deref().unwrap_or_default();
11853                            ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message({
11854                                let mut out = String::new();
11855                                out.push_str("Invalid ARN: `");
11856                                #[allow(clippy::needless_borrow)]
11857                                out.push_str(&bucket.as_ref());
11858                                out.push_str("` was not a valid ARN");
11859                                out
11860                            })) as ::aws_smithy_runtime_api::box_error::BoxError)
11861                        }
11862                        88 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
11863                            "Path-style addressing cannot be used with ARN buckets".to_string(),
11864                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
11865                        89 => {
11866                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
11867                            let uri_encoded_bucket = context
11868                                .uri_encoded_bucket
11869                                .as_ref()
11870                                .expect("Guaranteed to have a value by earlier checks.");
11871                            ::std::result::Result::Ok(
11872                                ::aws_smithy_types::endpoint::Endpoint::builder()
11873                                    .url({
11874                                        let mut out = String::new();
11875                                        out.push_str("https://s3-fips.dualstack.us-east-1.");
11876                                        #[allow(clippy::needless_borrow)]
11877                                        out.push_str(&partition_result.dns_suffix());
11878                                        out.push_str("/");
11879                                        #[allow(clippy::needless_borrow)]
11880                                        out.push_str(&uri_encoded_bucket.as_ref());
11881                                        out
11882                                    })
11883                                    .auth_scheme(
11884                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11885                                            .put("disableDoubleEncoding", true)
11886                                            .put("signingName", "s3")
11887                                            .put("signingRegion", "us-east-1"),
11888                                    )
11889                                    .build(),
11890                            )
11891                        }
11892                        90 => {
11893                            let region = params.region.as_deref().unwrap_or_default();
11894                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
11895                            let uri_encoded_bucket = context
11896                                .uri_encoded_bucket
11897                                .as_ref()
11898                                .expect("Guaranteed to have a value by earlier checks.");
11899                            ::std::result::Result::Ok(
11900                                ::aws_smithy_types::endpoint::Endpoint::builder()
11901                                    .url({
11902                                        let mut out = String::new();
11903                                        out.push_str("https://s3-fips.dualstack.");
11904                                        #[allow(clippy::needless_borrow)]
11905                                        out.push_str(&region.as_ref());
11906                                        out.push_str(".");
11907                                        #[allow(clippy::needless_borrow)]
11908                                        out.push_str(&partition_result.dns_suffix());
11909                                        out.push_str("/");
11910                                        #[allow(clippy::needless_borrow)]
11911                                        out.push_str(&uri_encoded_bucket.as_ref());
11912                                        out
11913                                    })
11914                                    .auth_scheme(
11915                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11916                                            .put("disableDoubleEncoding", true)
11917                                            .put("signingName", "s3")
11918                                            .put("signingRegion", region.as_ref()),
11919                                    )
11920                                    .build(),
11921                            )
11922                        }
11923                        91 => {
11924                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
11925                            let uri_encoded_bucket = context
11926                                .uri_encoded_bucket
11927                                .as_ref()
11928                                .expect("Guaranteed to have a value by earlier checks.");
11929                            ::std::result::Result::Ok(
11930                                ::aws_smithy_types::endpoint::Endpoint::builder()
11931                                    .url({
11932                                        let mut out = String::new();
11933                                        out.push_str("https://s3-fips.us-east-1.");
11934                                        #[allow(clippy::needless_borrow)]
11935                                        out.push_str(&partition_result.dns_suffix());
11936                                        out.push_str("/");
11937                                        #[allow(clippy::needless_borrow)]
11938                                        out.push_str(&uri_encoded_bucket.as_ref());
11939                                        out
11940                                    })
11941                                    .auth_scheme(
11942                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11943                                            .put("disableDoubleEncoding", true)
11944                                            .put("signingName", "s3")
11945                                            .put("signingRegion", "us-east-1"),
11946                                    )
11947                                    .build(),
11948                            )
11949                        }
11950                        92 => {
11951                            let region = params.region.as_deref().unwrap_or_default();
11952                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
11953                            let uri_encoded_bucket = context
11954                                .uri_encoded_bucket
11955                                .as_ref()
11956                                .expect("Guaranteed to have a value by earlier checks.");
11957                            ::std::result::Result::Ok(
11958                                ::aws_smithy_types::endpoint::Endpoint::builder()
11959                                    .url({
11960                                        let mut out = String::new();
11961                                        out.push_str("https://s3-fips.");
11962                                        #[allow(clippy::needless_borrow)]
11963                                        out.push_str(&region.as_ref());
11964                                        out.push_str(".");
11965                                        #[allow(clippy::needless_borrow)]
11966                                        out.push_str(&partition_result.dns_suffix());
11967                                        out.push_str("/");
11968                                        #[allow(clippy::needless_borrow)]
11969                                        out.push_str(&uri_encoded_bucket.as_ref());
11970                                        out
11971                                    })
11972                                    .auth_scheme(
11973                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
11974                                            .put("disableDoubleEncoding", true)
11975                                            .put("signingName", "s3")
11976                                            .put("signingRegion", region.as_ref()),
11977                                    )
11978                                    .build(),
11979                            )
11980                        }
11981                        93 => {
11982                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
11983                            let uri_encoded_bucket = context
11984                                .uri_encoded_bucket
11985                                .as_ref()
11986                                .expect("Guaranteed to have a value by earlier checks.");
11987                            ::std::result::Result::Ok(
11988                                ::aws_smithy_types::endpoint::Endpoint::builder()
11989                                    .url({
11990                                        let mut out = String::new();
11991                                        out.push_str("https://s3.dualstack.us-east-1.");
11992                                        #[allow(clippy::needless_borrow)]
11993                                        out.push_str(&partition_result.dns_suffix());
11994                                        out.push_str("/");
11995                                        #[allow(clippy::needless_borrow)]
11996                                        out.push_str(&uri_encoded_bucket.as_ref());
11997                                        out
11998                                    })
11999                                    .auth_scheme(
12000                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12001                                            .put("disableDoubleEncoding", true)
12002                                            .put("signingName", "s3")
12003                                            .put("signingRegion", "us-east-1"),
12004                                    )
12005                                    .build(),
12006                            )
12007                        }
12008                        94 => {
12009                            let region = params.region.as_deref().unwrap_or_default();
12010                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12011                            let uri_encoded_bucket = context
12012                                .uri_encoded_bucket
12013                                .as_ref()
12014                                .expect("Guaranteed to have a value by earlier checks.");
12015                            ::std::result::Result::Ok(
12016                                ::aws_smithy_types::endpoint::Endpoint::builder()
12017                                    .url({
12018                                        let mut out = String::new();
12019                                        out.push_str("https://s3.dualstack.");
12020                                        #[allow(clippy::needless_borrow)]
12021                                        out.push_str(&region.as_ref());
12022                                        out.push_str(".");
12023                                        #[allow(clippy::needless_borrow)]
12024                                        out.push_str(&partition_result.dns_suffix());
12025                                        out.push_str("/");
12026                                        #[allow(clippy::needless_borrow)]
12027                                        out.push_str(&uri_encoded_bucket.as_ref());
12028                                        out
12029                                    })
12030                                    .auth_scheme(
12031                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12032                                            .put("disableDoubleEncoding", true)
12033                                            .put("signingName", "s3")
12034                                            .put("signingRegion", region.as_ref()),
12035                                    )
12036                                    .build(),
12037                            )
12038                        }
12039                        95 => {
12040                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
12041                            let uri_encoded_bucket = context
12042                                .uri_encoded_bucket
12043                                .as_ref()
12044                                .expect("Guaranteed to have a value by earlier checks.");
12045                            ::std::result::Result::Ok(
12046                                ::aws_smithy_types::endpoint::Endpoint::builder()
12047                                    .url({
12048                                        let mut out = String::new();
12049                                        #[allow(clippy::needless_borrow)]
12050                                        out.push_str(&url.scheme());
12051                                        out.push_str("://");
12052                                        #[allow(clippy::needless_borrow)]
12053                                        out.push_str(&url.authority());
12054                                        #[allow(clippy::needless_borrow)]
12055                                        out.push_str(&url.normalized_path());
12056                                        #[allow(clippy::needless_borrow)]
12057                                        out.push_str(&uri_encoded_bucket.as_ref());
12058                                        out
12059                                    })
12060                                    .auth_scheme(
12061                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12062                                            .put("disableDoubleEncoding", true)
12063                                            .put("signingName", "s3")
12064                                            .put("signingRegion", "us-east-1"),
12065                                    )
12066                                    .build(),
12067                            )
12068                        }
12069                        96 => {
12070                            let region = params.region.as_deref().unwrap_or_default();
12071                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
12072                            let uri_encoded_bucket = context
12073                                .uri_encoded_bucket
12074                                .as_ref()
12075                                .expect("Guaranteed to have a value by earlier checks.");
12076                            ::std::result::Result::Ok(
12077                                ::aws_smithy_types::endpoint::Endpoint::builder()
12078                                    .url({
12079                                        let mut out = String::new();
12080                                        #[allow(clippy::needless_borrow)]
12081                                        out.push_str(&url.scheme());
12082                                        out.push_str("://");
12083                                        #[allow(clippy::needless_borrow)]
12084                                        out.push_str(&url.authority());
12085                                        #[allow(clippy::needless_borrow)]
12086                                        out.push_str(&url.normalized_path());
12087                                        #[allow(clippy::needless_borrow)]
12088                                        out.push_str(&uri_encoded_bucket.as_ref());
12089                                        out
12090                                    })
12091                                    .auth_scheme(
12092                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12093                                            .put("disableDoubleEncoding", true)
12094                                            .put("signingName", "s3")
12095                                            .put("signingRegion", region.as_ref()),
12096                                    )
12097                                    .build(),
12098                            )
12099                        }
12100                        97 => {
12101                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12102                            let uri_encoded_bucket = context
12103                                .uri_encoded_bucket
12104                                .as_ref()
12105                                .expect("Guaranteed to have a value by earlier checks.");
12106                            ::std::result::Result::Ok(
12107                                ::aws_smithy_types::endpoint::Endpoint::builder()
12108                                    .url({
12109                                        let mut out = String::new();
12110                                        out.push_str("https://s3.");
12111                                        #[allow(clippy::needless_borrow)]
12112                                        out.push_str(&partition_result.dns_suffix());
12113                                        out.push_str("/");
12114                                        #[allow(clippy::needless_borrow)]
12115                                        out.push_str(&uri_encoded_bucket.as_ref());
12116                                        out
12117                                    })
12118                                    .auth_scheme(
12119                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12120                                            .put("disableDoubleEncoding", true)
12121                                            .put("signingName", "s3")
12122                                            .put("signingRegion", "us-east-1"),
12123                                    )
12124                                    .build(),
12125                            )
12126                        }
12127                        98 => {
12128                            let region = params.region.as_deref().unwrap_or_default();
12129                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12130                            let uri_encoded_bucket = context
12131                                .uri_encoded_bucket
12132                                .as_ref()
12133                                .expect("Guaranteed to have a value by earlier checks.");
12134                            ::std::result::Result::Ok(
12135                                ::aws_smithy_types::endpoint::Endpoint::builder()
12136                                    .url({
12137                                        let mut out = String::new();
12138                                        out.push_str("https://s3.");
12139                                        #[allow(clippy::needless_borrow)]
12140                                        out.push_str(&partition_result.dns_suffix());
12141                                        out.push_str("/");
12142                                        #[allow(clippy::needless_borrow)]
12143                                        out.push_str(&uri_encoded_bucket.as_ref());
12144                                        out
12145                                    })
12146                                    .auth_scheme(
12147                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12148                                            .put("disableDoubleEncoding", true)
12149                                            .put("signingName", "s3")
12150                                            .put("signingRegion", region.as_ref()),
12151                                    )
12152                                    .build(),
12153                            )
12154                        }
12155                        99 => {
12156                            let region = params.region.as_deref().unwrap_or_default();
12157                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12158                            let uri_encoded_bucket = context
12159                                .uri_encoded_bucket
12160                                .as_ref()
12161                                .expect("Guaranteed to have a value by earlier checks.");
12162                            ::std::result::Result::Ok(
12163                                ::aws_smithy_types::endpoint::Endpoint::builder()
12164                                    .url({
12165                                        let mut out = String::new();
12166                                        out.push_str("https://s3.");
12167                                        #[allow(clippy::needless_borrow)]
12168                                        out.push_str(&region.as_ref());
12169                                        out.push_str(".");
12170                                        #[allow(clippy::needless_borrow)]
12171                                        out.push_str(&partition_result.dns_suffix());
12172                                        out.push_str("/");
12173                                        #[allow(clippy::needless_borrow)]
12174                                        out.push_str(&uri_encoded_bucket.as_ref());
12175                                        out
12176                                    })
12177                                    .auth_scheme(
12178                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12179                                            .put("disableDoubleEncoding", true)
12180                                            .put("signingName", "s3")
12181                                            .put("signingRegion", region.as_ref()),
12182                                    )
12183                                    .build(),
12184                            )
12185                        }
12186                        100 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
12187                            "Path-style addressing cannot be used with S3 Accelerate".to_string(),
12188                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
12189                        101 => {
12190                            let region = params.region.as_deref().unwrap_or_default();
12191                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
12192                            ::std::result::Result::Ok(
12193                                ::aws_smithy_types::endpoint::Endpoint::builder()
12194                                    .url({
12195                                        let mut out = String::new();
12196                                        #[allow(clippy::needless_borrow)]
12197                                        out.push_str(&url.scheme());
12198                                        out.push_str("://");
12199                                        #[allow(clippy::needless_borrow)]
12200                                        out.push_str(&url.authority());
12201                                        #[allow(clippy::needless_borrow)]
12202                                        out.push_str(&url.path());
12203                                        out
12204                                    })
12205                                    .auth_scheme(
12206                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12207                                            .put("disableDoubleEncoding", true)
12208                                            .put("signingName", "s3-object-lambda")
12209                                            .put("signingRegion", region.as_ref()),
12210                                    )
12211                                    .build(),
12212                            )
12213                        }
12214                        102 => {
12215                            let region = params.region.as_deref().unwrap_or_default();
12216                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12217                            ::std::result::Result::Ok(
12218                                ::aws_smithy_types::endpoint::Endpoint::builder()
12219                                    .url({
12220                                        let mut out = String::new();
12221                                        out.push_str("https://s3-object-lambda-fips.");
12222                                        #[allow(clippy::needless_borrow)]
12223                                        out.push_str(&region.as_ref());
12224                                        out.push_str(".");
12225                                        #[allow(clippy::needless_borrow)]
12226                                        out.push_str(&partition_result.dns_suffix());
12227                                        out
12228                                    })
12229                                    .auth_scheme(
12230                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12231                                            .put("disableDoubleEncoding", true)
12232                                            .put("signingName", "s3-object-lambda")
12233                                            .put("signingRegion", region.as_ref()),
12234                                    )
12235                                    .build(),
12236                            )
12237                        }
12238                        103 => {
12239                            let region = params.region.as_deref().unwrap_or_default();
12240                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12241                            ::std::result::Result::Ok(
12242                                ::aws_smithy_types::endpoint::Endpoint::builder()
12243                                    .url({
12244                                        let mut out = String::new();
12245                                        out.push_str("https://s3-object-lambda.");
12246                                        #[allow(clippy::needless_borrow)]
12247                                        out.push_str(&region.as_ref());
12248                                        out.push_str(".");
12249                                        #[allow(clippy::needless_borrow)]
12250                                        out.push_str(&partition_result.dns_suffix());
12251                                        out
12252                                    })
12253                                    .auth_scheme(
12254                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12255                                            .put("disableDoubleEncoding", true)
12256                                            .put("signingName", "s3-object-lambda")
12257                                            .put("signingRegion", region.as_ref()),
12258                                    )
12259                                    .build(),
12260                            )
12261                        }
12262                        104 => {
12263                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12264                            ::std::result::Result::Ok(
12265                                ::aws_smithy_types::endpoint::Endpoint::builder()
12266                                    .url({
12267                                        let mut out = String::new();
12268                                        out.push_str("https://s3-fips.dualstack.us-east-1.");
12269                                        #[allow(clippy::needless_borrow)]
12270                                        out.push_str(&partition_result.dns_suffix());
12271                                        out
12272                                    })
12273                                    .auth_scheme(
12274                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12275                                            .put("disableDoubleEncoding", true)
12276                                            .put("signingName", "s3")
12277                                            .put("signingRegion", "us-east-1"),
12278                                    )
12279                                    .build(),
12280                            )
12281                        }
12282                        105 => {
12283                            let region = params.region.as_deref().unwrap_or_default();
12284                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12285                            ::std::result::Result::Ok(
12286                                ::aws_smithy_types::endpoint::Endpoint::builder()
12287                                    .url({
12288                                        let mut out = String::new();
12289                                        out.push_str("https://s3-fips.dualstack.");
12290                                        #[allow(clippy::needless_borrow)]
12291                                        out.push_str(&region.as_ref());
12292                                        out.push_str(".");
12293                                        #[allow(clippy::needless_borrow)]
12294                                        out.push_str(&partition_result.dns_suffix());
12295                                        out
12296                                    })
12297                                    .auth_scheme(
12298                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12299                                            .put("disableDoubleEncoding", true)
12300                                            .put("signingName", "s3")
12301                                            .put("signingRegion", region.as_ref()),
12302                                    )
12303                                    .build(),
12304                            )
12305                        }
12306                        106 => {
12307                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12308                            ::std::result::Result::Ok(
12309                                ::aws_smithy_types::endpoint::Endpoint::builder()
12310                                    .url({
12311                                        let mut out = String::new();
12312                                        out.push_str("https://s3-fips.us-east-1.");
12313                                        #[allow(clippy::needless_borrow)]
12314                                        out.push_str(&partition_result.dns_suffix());
12315                                        out
12316                                    })
12317                                    .auth_scheme(
12318                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12319                                            .put("disableDoubleEncoding", true)
12320                                            .put("signingName", "s3")
12321                                            .put("signingRegion", "us-east-1"),
12322                                    )
12323                                    .build(),
12324                            )
12325                        }
12326                        107 => {
12327                            let region = params.region.as_deref().unwrap_or_default();
12328                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12329                            ::std::result::Result::Ok(
12330                                ::aws_smithy_types::endpoint::Endpoint::builder()
12331                                    .url({
12332                                        let mut out = String::new();
12333                                        out.push_str("https://s3-fips.");
12334                                        #[allow(clippy::needless_borrow)]
12335                                        out.push_str(&region.as_ref());
12336                                        out.push_str(".");
12337                                        #[allow(clippy::needless_borrow)]
12338                                        out.push_str(&partition_result.dns_suffix());
12339                                        out
12340                                    })
12341                                    .auth_scheme(
12342                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12343                                            .put("disableDoubleEncoding", true)
12344                                            .put("signingName", "s3")
12345                                            .put("signingRegion", region.as_ref()),
12346                                    )
12347                                    .build(),
12348                            )
12349                        }
12350                        108 => {
12351                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12352                            ::std::result::Result::Ok(
12353                                ::aws_smithy_types::endpoint::Endpoint::builder()
12354                                    .url({
12355                                        let mut out = String::new();
12356                                        out.push_str("https://s3.dualstack.us-east-1.");
12357                                        #[allow(clippy::needless_borrow)]
12358                                        out.push_str(&partition_result.dns_suffix());
12359                                        out
12360                                    })
12361                                    .auth_scheme(
12362                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12363                                            .put("disableDoubleEncoding", true)
12364                                            .put("signingName", "s3")
12365                                            .put("signingRegion", "us-east-1"),
12366                                    )
12367                                    .build(),
12368                            )
12369                        }
12370                        109 => {
12371                            let region = params.region.as_deref().unwrap_or_default();
12372                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12373                            ::std::result::Result::Ok(
12374                                ::aws_smithy_types::endpoint::Endpoint::builder()
12375                                    .url({
12376                                        let mut out = String::new();
12377                                        out.push_str("https://s3.dualstack.");
12378                                        #[allow(clippy::needless_borrow)]
12379                                        out.push_str(&region.as_ref());
12380                                        out.push_str(".");
12381                                        #[allow(clippy::needless_borrow)]
12382                                        out.push_str(&partition_result.dns_suffix());
12383                                        out
12384                                    })
12385                                    .auth_scheme(
12386                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12387                                            .put("disableDoubleEncoding", true)
12388                                            .put("signingName", "s3")
12389                                            .put("signingRegion", region.as_ref()),
12390                                    )
12391                                    .build(),
12392                            )
12393                        }
12394                        110 => {
12395                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
12396                            ::std::result::Result::Ok(
12397                                ::aws_smithy_types::endpoint::Endpoint::builder()
12398                                    .url({
12399                                        let mut out = String::new();
12400                                        #[allow(clippy::needless_borrow)]
12401                                        out.push_str(&url.scheme());
12402                                        out.push_str("://");
12403                                        #[allow(clippy::needless_borrow)]
12404                                        out.push_str(&url.authority());
12405                                        #[allow(clippy::needless_borrow)]
12406                                        out.push_str(&url.path());
12407                                        out
12408                                    })
12409                                    .auth_scheme(
12410                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12411                                            .put("disableDoubleEncoding", true)
12412                                            .put("signingName", "s3")
12413                                            .put("signingRegion", "us-east-1"),
12414                                    )
12415                                    .build(),
12416                            )
12417                        }
12418                        111 => {
12419                            let region = params.region.as_deref().unwrap_or_default();
12420                            let url = context.url.as_ref().expect("Guaranteed to have a value by earlier checks.");
12421                            ::std::result::Result::Ok(
12422                                ::aws_smithy_types::endpoint::Endpoint::builder()
12423                                    .url({
12424                                        let mut out = String::new();
12425                                        #[allow(clippy::needless_borrow)]
12426                                        out.push_str(&url.scheme());
12427                                        out.push_str("://");
12428                                        #[allow(clippy::needless_borrow)]
12429                                        out.push_str(&url.authority());
12430                                        #[allow(clippy::needless_borrow)]
12431                                        out.push_str(&url.path());
12432                                        out
12433                                    })
12434                                    .auth_scheme(
12435                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12436                                            .put("disableDoubleEncoding", true)
12437                                            .put("signingName", "s3")
12438                                            .put("signingRegion", region.as_ref()),
12439                                    )
12440                                    .build(),
12441                            )
12442                        }
12443                        112 => {
12444                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12445                            ::std::result::Result::Ok(
12446                                ::aws_smithy_types::endpoint::Endpoint::builder()
12447                                    .url({
12448                                        let mut out = String::new();
12449                                        out.push_str("https://s3.");
12450                                        #[allow(clippy::needless_borrow)]
12451                                        out.push_str(&partition_result.dns_suffix());
12452                                        out
12453                                    })
12454                                    .auth_scheme(
12455                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12456                                            .put("disableDoubleEncoding", true)
12457                                            .put("signingName", "s3")
12458                                            .put("signingRegion", "us-east-1"),
12459                                    )
12460                                    .build(),
12461                            )
12462                        }
12463                        113 => {
12464                            let region = params.region.as_deref().unwrap_or_default();
12465                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12466                            ::std::result::Result::Ok(
12467                                ::aws_smithy_types::endpoint::Endpoint::builder()
12468                                    .url({
12469                                        let mut out = String::new();
12470                                        out.push_str("https://s3.");
12471                                        #[allow(clippy::needless_borrow)]
12472                                        out.push_str(&partition_result.dns_suffix());
12473                                        out
12474                                    })
12475                                    .auth_scheme(
12476                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12477                                            .put("disableDoubleEncoding", true)
12478                                            .put("signingName", "s3")
12479                                            .put("signingRegion", region.as_ref()),
12480                                    )
12481                                    .build(),
12482                            )
12483                        }
12484                        114 => {
12485                            let region = params.region.as_deref().unwrap_or_default();
12486                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
12487                            ::std::result::Result::Ok(
12488                                ::aws_smithy_types::endpoint::Endpoint::builder()
12489                                    .url({
12490                                        let mut out = String::new();
12491                                        out.push_str("https://s3.");
12492                                        #[allow(clippy::needless_borrow)]
12493                                        out.push_str(&region.as_ref());
12494                                        out.push_str(".");
12495                                        #[allow(clippy::needless_borrow)]
12496                                        out.push_str(&partition_result.dns_suffix());
12497                                        out
12498                                    })
12499                                    .auth_scheme(
12500                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 3)
12501                                            .put("disableDoubleEncoding", true)
12502                                            .put("signingName", "s3")
12503                                            .put("signingRegion", region.as_ref()),
12504                                    )
12505                                    .build(),
12506                            )
12507                        }
12508                        115 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
12509                            "A region must be set when sending requests to S3.".to_string(),
12510                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
12511                        _ => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
12512                            "No endpoint rule matched",
12513                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
12514                    };
12515                }
12516                1 | -1 => {
12517                    return ::std::result::Result::Err(
12518                        Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("No endpoint rule matched"))
12519                            as ::aws_smithy_runtime_api::box_error::BoxError,
12520                    )
12521                }
12522                ref_val => {
12523                    let is_complement = ref_val < 0;
12524                    let node = &NODES[(ref_val.unsigned_abs() as usize) - 1];
12525                    let condition_result = match node.condition_index {
12526                        0 => region.is_some(),
12527                        1 => (accelerate) == (&true),
12528                        2 => (use_fips) == (&true),
12529                        3 => (use_dual_stack) == (&true),
12530                        4 => endpoint.is_some(),
12531                        5 => bucket.is_some(),
12532                        6 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12533                            let partition_resolver = &self.partition_resolver;
12534                            (crate::endpoint_lib::coalesce::coalesce!(
12535                                if let Some(inner) = crate::endpoint_lib::substring::substring(
12536                                    if let Some(param) = bucket { param } else { return false },
12537                                    0,
12538                                    6,
12539                                    true,
12540                                    _diagnostic_collector
12541                                ) {
12542                                    inner
12543                                } else {
12544                                    return false;
12545                                },
12546                                "".to_string()
12547                            )) == ("--x-s3")
12548                        })(&mut _diagnostic_collector),
12549                        7 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12550                            let partition_resolver = &self.partition_resolver;
12551                            (crate::endpoint_lib::coalesce::coalesce!(
12552                                if let Some(inner) = crate::endpoint_lib::substring::substring(
12553                                    if let Some(param) = bucket { param } else { return false },
12554                                    0,
12555                                    7,
12556                                    true,
12557                                    _diagnostic_collector
12558                                ) {
12559                                    inner
12560                                } else {
12561                                    return false;
12562                                },
12563                                "".to_string()
12564                            )) == ("--xa-s3")
12565                        })(&mut _diagnostic_collector),
12566                        8 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12567                            let partition_result = &mut context.partition_result;
12568                            let partition_resolver = &self.partition_resolver;
12569                            {
12570                                *partition_result = partition_resolver
12571                                    .resolve_partition(if let Some(param) = region { param } else { return false }, _diagnostic_collector)
12572                                    .map(|inner| inner.into());
12573                                partition_result.is_some()
12574                            }
12575                        })(&mut _diagnostic_collector),
12576                        9 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12577                            let access_point_suffix = &mut context.access_point_suffix;
12578                            let partition_resolver = &self.partition_resolver;
12579                            {
12580                                *access_point_suffix = crate::endpoint_lib::substring::substring(
12581                                    if let Some(param) = bucket { param } else { return false },
12582                                    0,
12583                                    7,
12584                                    true,
12585                                    _diagnostic_collector,
12586                                )
12587                                .map(|inner| inner.into());
12588                                access_point_suffix.is_some()
12589                            }
12590                        })(&mut _diagnostic_collector),
12591                        10 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12592                            let access_point_suffix = &context.access_point_suffix;
12593                            let partition_resolver = &self.partition_resolver;
12594                            (access_point_suffix) == &mut Some(("--op-s3".to_string().into()))
12595                        })(&mut _diagnostic_collector),
12596                        11 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12597                            let region_prefix = &mut context.region_prefix;
12598                            let partition_resolver = &self.partition_resolver;
12599                            {
12600                                *region_prefix = crate::endpoint_lib::substring::substring(
12601                                    if let Some(param) = bucket { param } else { return false },
12602                                    8,
12603                                    12,
12604                                    true,
12605                                    _diagnostic_collector,
12606                                )
12607                                .map(|inner| inner.into());
12608                                region_prefix.is_some()
12609                            }
12610                        })(&mut _diagnostic_collector),
12611                        12 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12612                            let outpost_id_ssa_2 = &mut context.outpost_id_ssa_2;
12613                            let partition_resolver = &self.partition_resolver;
12614                            {
12615                                *outpost_id_ssa_2 = crate::endpoint_lib::substring::substring(
12616                                    if let Some(param) = bucket { param } else { return false },
12617                                    32,
12618                                    49,
12619                                    true,
12620                                    _diagnostic_collector,
12621                                )
12622                                .map(|inner| inner.into());
12623                                outpost_id_ssa_2.is_some()
12624                            }
12625                        })(&mut _diagnostic_collector),
12626                        13 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12627                            let hardware_type = &mut context.hardware_type;
12628                            let partition_resolver = &self.partition_resolver;
12629                            {
12630                                *hardware_type = crate::endpoint_lib::substring::substring(
12631                                    if let Some(param) = bucket { param } else { return false },
12632                                    49,
12633                                    50,
12634                                    true,
12635                                    _diagnostic_collector,
12636                                )
12637                                .map(|inner| inner.into());
12638                                hardware_type.is_some()
12639                            }
12640                        })(&mut _diagnostic_collector),
12641                        14 => (force_path_style) == (&true),
12642                        15 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12643                            let partition_result = &context.partition_result;
12644                            let partition_resolver = &self.partition_resolver;
12645                            (if let Some(inner) = partition_result {
12646                                inner.name()
12647                            } else {
12648                                return false;
12649                            }) == ("aws-cn")
12650                        })(&mut _diagnostic_collector),
12651                        16 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12652                            let s3_e_ds = &mut context.s3_e_ds;
12653                            let partition_resolver = &self.partition_resolver;
12654                            {
12655                                *s3_e_ds = Some(crate::endpoint_lib::ite::ite!(use_dual_stack, ".dualstack".to_string(), "".to_string()).into());
12656                                true
12657                            }
12658                        })(&mut _diagnostic_collector),
12659                        17 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12660                            let outpost_id_ssa_2 = &context.outpost_id_ssa_2;
12661                            let partition_resolver = &self.partition_resolver;
12662                            crate::endpoint_lib::host::is_valid_host_label(
12663                                if let Some(param) = outpost_id_ssa_2 { param } else { return false },
12664                                false,
12665                                _diagnostic_collector,
12666                            )
12667                        })(&mut _diagnostic_collector),
12668                        18 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12669                            let s3_e_fips = &mut context.s3_e_fips;
12670                            let partition_resolver = &self.partition_resolver;
12671                            {
12672                                *s3_e_fips = Some(crate::endpoint_lib::ite::ite!(use_fips, "-fips".to_string(), "".to_string()).into());
12673                                true
12674                            }
12675                        })(&mut _diagnostic_collector),
12676                        19 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12677                            let s3_e_auth = &mut context.s3_e_auth;
12678                            let partition_resolver = &self.partition_resolver;
12679                            {
12680                                *s3_e_auth = Some(
12681                                    crate::endpoint_lib::ite::ite!(
12682                                        crate::endpoint_lib::coalesce::coalesce!(disable_s3_express_session_auth.clone(), false),
12683                                        "sigv4".to_string(),
12684                                        "sigv4-s3express".to_string()
12685                                    )
12686                                    .into(),
12687                                );
12688                                true
12689                            }
12690                        })(&mut _diagnostic_collector),
12691                        20 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12692                            let partition_resolver = &self.partition_resolver;
12693                            crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(
12694                                if let Some(param) = bucket { param } else { return false },
12695                                false,
12696                                _diagnostic_collector,
12697                            )
12698                        })(&mut _diagnostic_collector),
12699                        21 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12700                            let url = &mut context.url;
12701                            let partition_resolver = &self.partition_resolver;
12702                            {
12703                                *url = crate::endpoint_lib::parse_url::parse_url(
12704                                    if let Some(param) = endpoint { param } else { return false },
12705                                    _diagnostic_collector,
12706                                )
12707                                .map(|inner| inner.into());
12708                                url.is_some()
12709                            }
12710                        })(&mut _diagnostic_collector),
12711                        22 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12712                            let partition_resolver = &self.partition_resolver;
12713                            (crate::endpoint_lib::coalesce::coalesce!(use_s3_express_control_endpoint.clone(), false)) == (true)
12714                        })(&mut _diagnostic_collector),
12715                        23 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12716                            let partition_resolver = &self.partition_resolver;
12717                            crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(
12718                                if let Some(param) = bucket { param } else { return false },
12719                                true,
12720                                _diagnostic_collector,
12721                            )
12722                        })(&mut _diagnostic_collector),
12723                        24 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12724                            let url = &context.url;
12725                            let partition_resolver = &self.partition_resolver;
12726                            (if let Some(inner) = url { inner.scheme() } else { return false }) == ("http")
12727                        })(&mut _diagnostic_collector),
12728                        25 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12729                            let partition_resolver = &self.partition_resolver;
12730                            crate::endpoint_lib::host::is_valid_host_label(
12731                                if let Some(param) = region { param } else { return false },
12732                                false,
12733                                _diagnostic_collector,
12734                            )
12735                        })(&mut _diagnostic_collector),
12736                        26 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12737                            let bucket_arn = &mut context.bucket_arn;
12738                            let partition_resolver = &self.partition_resolver;
12739                            {
12740                                *bucket_arn = crate::endpoint_lib::arn::parse_arn(
12741                                    if let Some(param) = bucket { param } else { return false },
12742                                    _diagnostic_collector,
12743                                )
12744                                .map(|inner| inner.into());
12745                                bucket_arn.is_some()
12746                            }
12747                        })(&mut _diagnostic_collector),
12748                        27 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12749                            let s3express_availability_zone_id = &mut context.s3express_availability_zone_id;
12750                            let partition_resolver = &self.partition_resolver;
12751                            {
12752                                *s3express_availability_zone_id = crate::endpoint_lib::split::split(
12753                                    if let Some(param) = bucket { param } else { return false },
12754                                    "--",
12755                                    0,
12756                                    _diagnostic_collector,
12757                                )
12758                                .iter()
12759                                .nth_back(1)
12760                                .cloned()
12761                                .map(|inner| inner.into());
12762                                s3express_availability_zone_id.is_some()
12763                            }
12764                        })(&mut _diagnostic_collector),
12765                        28 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12766                            let partition_resolver = &self.partition_resolver;
12767                            (crate::endpoint_lib::coalesce::coalesce!(
12768                                if let Some(inner) = crate::endpoint_lib::substring::substring(
12769                                    if let Some(param) = bucket { param } else { return false },
12770                                    0,
12771                                    4,
12772                                    false,
12773                                    _diagnostic_collector
12774                                ) {
12775                                    inner
12776                                } else {
12777                                    return false;
12778                                },
12779                                "".to_string()
12780                            )) == ("arn:")
12781                        })(&mut _diagnostic_collector),
12782                        29 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12783                            let partition_resolver = &self.partition_resolver;
12784                            (crate::endpoint_lib::coalesce::coalesce!(
12785                                if let Some(inner) = crate::endpoint_lib::substring::substring(
12786                                    if let Some(param) = bucket { param } else { return false },
12787                                    16,
12788                                    18,
12789                                    true,
12790                                    _diagnostic_collector
12791                                ) {
12792                                    inner
12793                                } else {
12794                                    return false;
12795                                },
12796                                "".to_string()
12797                            )) == ("--")
12798                        })(&mut _diagnostic_collector),
12799                        30 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12800                            let url = &context.url;
12801                            let partition_resolver = &self.partition_resolver;
12802                            (if let Some(inner) = url { inner.is_ip() } else { return false }) == (true)
12803                        })(&mut _diagnostic_collector),
12804                        31 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12805                            let partition_resolver = &self.partition_resolver;
12806                            (crate::endpoint_lib::coalesce::coalesce!(
12807                                if let Some(inner) = crate::endpoint_lib::substring::substring(
12808                                    if let Some(param) = bucket { param } else { return false },
12809                                    21,
12810                                    23,
12811                                    true,
12812                                    _diagnostic_collector
12813                                ) {
12814                                    inner
12815                                } else {
12816                                    return false;
12817                                },
12818                                "".to_string()
12819                            )) == ("--")
12820                        })(&mut _diagnostic_collector),
12821                        32 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12822                            let partition_resolver = &self.partition_resolver;
12823                            (crate::endpoint_lib::coalesce::coalesce!(
12824                                if let Some(inner) = crate::endpoint_lib::substring::substring(
12825                                    if let Some(param) = bucket { param } else { return false },
12826                                    27,
12827                                    29,
12828                                    true,
12829                                    _diagnostic_collector
12830                                ) {
12831                                    inner
12832                                } else {
12833                                    return false;
12834                                },
12835                                "".to_string()
12836                            )) == ("--")
12837                        })(&mut _diagnostic_collector),
12838                        33 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12839                            let region_prefix = &context.region_prefix;
12840                            let partition_resolver = &self.partition_resolver;
12841                            (region_prefix) == &mut Some(("beta".to_string().into()))
12842                        })(&mut _diagnostic_collector),
12843                        34 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12844                            let uri_encoded_bucket = &mut context.uri_encoded_bucket;
12845                            let partition_resolver = &self.partition_resolver;
12846                            {
12847                                *uri_encoded_bucket = Some(
12848                                    crate::endpoint_lib::uri_encode::uri_encode(
12849                                        if let Some(param) = bucket { param } else { return false },
12850                                        _diagnostic_collector,
12851                                    )
12852                                    .into(),
12853                                );
12854                                true
12855                            }
12856                        })(&mut _diagnostic_collector),
12857                        35 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12858                            let partition_resolver = &self.partition_resolver;
12859                            crate::endpoint_lib::host::is_valid_host_label(
12860                                if let Some(param) = region { param } else { return false },
12861                                true,
12862                                _diagnostic_collector,
12863                            )
12864                        })(&mut _diagnostic_collector),
12865                        36 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12866                            let partition_resolver = &self.partition_resolver;
12867                            (crate::endpoint_lib::coalesce::coalesce!(use_object_lambda_endpoint.clone(), false)) == (true)
12868                        })(&mut _diagnostic_collector),
12869                        37 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12870                            let bucket_arn = &context.bucket_arn;
12871                            let arn_type = &mut context.arn_type;
12872                            let partition_resolver = &self.partition_resolver;
12873                            {
12874                                *arn_type = if let Some(inner) = bucket_arn {
12875                                    inner.resource_id().first().cloned()
12876                                } else {
12877                                    return false;
12878                                }
12879                                .map(|inner| inner.into());
12880                                arn_type.is_some()
12881                            }
12882                        })(&mut _diagnostic_collector),
12883                        38 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12884                            let arn_type = &context.arn_type;
12885                            let partition_resolver = &self.partition_resolver;
12886                            (arn_type) == &mut Some(("".to_string().into()))
12887                        })(&mut _diagnostic_collector),
12888                        39 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12889                            let arn_type = &context.arn_type;
12890                            let partition_resolver = &self.partition_resolver;
12891                            (arn_type) == &mut Some(("accesspoint".to_string().into()))
12892                        })(&mut _diagnostic_collector),
12893                        40 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12894                            let bucket_arn = &context.bucket_arn;
12895                            let access_point_name_ssa_1 = &mut context.access_point_name_ssa_1;
12896                            let partition_resolver = &self.partition_resolver;
12897                            {
12898                                *access_point_name_ssa_1 = if let Some(inner) = bucket_arn {
12899                                    inner.resource_id().get(1).cloned()
12900                                } else {
12901                                    return false;
12902                                }
12903                                .map(|inner| inner.into());
12904                                access_point_name_ssa_1.is_some()
12905                            }
12906                        })(&mut _diagnostic_collector),
12907                        41 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12908                            let access_point_name_ssa_1 = &context.access_point_name_ssa_1;
12909                            let partition_resolver = &self.partition_resolver;
12910                            (access_point_name_ssa_1) == &mut Some(("".to_string().into()))
12911                        })(&mut _diagnostic_collector),
12912                        42 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12913                            let bucket_arn = &context.bucket_arn;
12914                            let partition_resolver = &self.partition_resolver;
12915                            (if let Some(inner) = bucket_arn { inner.region() } else { return false }) == ("")
12916                        })(&mut _diagnostic_collector),
12917                        43 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12918                            let partition_resolver = &self.partition_resolver;
12919                            (crate::endpoint_lib::coalesce::coalesce!(
12920                                if let Some(inner) = crate::endpoint_lib::substring::substring(
12921                                    if let Some(param) = bucket { param } else { return false },
12922                                    14,
12923                                    16,
12924                                    true,
12925                                    _diagnostic_collector
12926                                ) {
12927                                    inner
12928                                } else {
12929                                    return false;
12930                                },
12931                                "".to_string()
12932                            )) == ("--")
12933                        })(&mut _diagnostic_collector),
12934                        44 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12935                            let hardware_type = &context.hardware_type;
12936                            let partition_resolver = &self.partition_resolver;
12937                            (hardware_type) == &mut Some(("e".to_string().into()))
12938                        })(&mut _diagnostic_collector),
12939                        45 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12940                            let hardware_type = &context.hardware_type;
12941                            let partition_resolver = &self.partition_resolver;
12942                            (hardware_type) == &mut Some(("o".to_string().into()))
12943                        })(&mut _diagnostic_collector),
12944                        46 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12945                            let partition_resolver = &self.partition_resolver;
12946                            (region) == &mut Some(("aws-global".to_string().into()))
12947                        })(&mut _diagnostic_collector),
12948                        47 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12949                            let partition_resolver = &self.partition_resolver;
12950                            (crate::endpoint_lib::coalesce::coalesce!(
12951                                if let Some(inner) = crate::endpoint_lib::substring::substring(
12952                                    if let Some(param) = bucket { param } else { return false },
12953                                    19,
12954                                    21,
12955                                    true,
12956                                    _diagnostic_collector
12957                                ) {
12958                                    inner
12959                                } else {
12960                                    return false;
12961                                },
12962                                "".to_string()
12963                            )) == ("--")
12964                        })(&mut _diagnostic_collector),
12965                        48 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12966                            let bucket_arn = &context.bucket_arn;
12967                            let partition_resolver = &self.partition_resolver;
12968                            (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3-object-lambda")
12969                        })(&mut _diagnostic_collector),
12970                        49 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12971                            let partition_resolver = &self.partition_resolver;
12972                            (crate::endpoint_lib::coalesce::coalesce!(disable_access_points.clone(), false)) == (true)
12973                        })(&mut _diagnostic_collector),
12974                        50 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12975                            let bucket_arn = &context.bucket_arn;
12976                            let partition_resolver = &self.partition_resolver;
12977                            (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3-outposts")
12978                        })(&mut _diagnostic_collector),
12979                        51 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12980                            let bucket_arn = &context.bucket_arn;
12981                            let bucket_partition = &mut context.bucket_partition;
12982                            let partition_resolver = &self.partition_resolver;
12983                            {
12984                                *bucket_partition = partition_resolver
12985                                    .resolve_partition(
12986                                        if let Some(inner) = bucket_arn { inner.region() } else { return false },
12987                                        _diagnostic_collector,
12988                                    )
12989                                    .map(|inner| inner.into());
12990                                bucket_partition.is_some()
12991                            }
12992                        })(&mut _diagnostic_collector),
12993                        52 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
12994                            let access_point_name_ssa_1 = &context.access_point_name_ssa_1;
12995                            let partition_resolver = &self.partition_resolver;
12996                            crate::endpoint_lib::host::is_valid_host_label(
12997                                if let Some(param) = access_point_name_ssa_1 {
12998                                    param
12999                                } else {
13000                                    return false;
13001                                },
13002                                true,
13003                                _diagnostic_collector,
13004                            )
13005                        })(&mut _diagnostic_collector),
13006                        53 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13007                            let partition_resolver = &self.partition_resolver;
13008                            (crate::endpoint_lib::coalesce::coalesce!(
13009                                if let Some(inner) = crate::endpoint_lib::substring::substring(
13010                                    if let Some(param) = bucket { param } else { return false },
13011                                    26,
13012                                    28,
13013                                    true,
13014                                    _diagnostic_collector
13015                                ) {
13016                                    inner
13017                                } else {
13018                                    return false;
13019                                },
13020                                "".to_string()
13021                            )) == ("--")
13022                        })(&mut _diagnostic_collector),
13023                        54 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13024                            let partition_resolver = &self.partition_resolver;
13025                            (crate::endpoint_lib::coalesce::coalesce!(
13026                                if let Some(inner) = crate::endpoint_lib::substring::substring(
13027                                    if let Some(param) = bucket { param } else { return false },
13028                                    15,
13029                                    17,
13030                                    true,
13031                                    _diagnostic_collector
13032                                ) {
13033                                    inner
13034                                } else {
13035                                    return false;
13036                                },
13037                                "".to_string()
13038                            )) == ("--")
13039                        })(&mut _diagnostic_collector),
13040                        55 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13041                            let bucket_arn = &context.bucket_arn;
13042                            let partition_resolver = &self.partition_resolver;
13043                            if let Some(inner) = bucket_arn {
13044                                inner.resource_id().get(4).cloned()
13045                            } else {
13046                                return false;
13047                            }
13048                            .is_some()
13049                        })(&mut _diagnostic_collector),
13050                        56 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13051                            let partition_resolver = &self.partition_resolver;
13052                            (crate::endpoint_lib::coalesce::coalesce!(
13053                                if let Some(inner) = crate::endpoint_lib::substring::substring(
13054                                    if let Some(param) = bucket { param } else { return false },
13055                                    20,
13056                                    22,
13057                                    true,
13058                                    _diagnostic_collector
13059                                ) {
13060                                    inner
13061                                } else {
13062                                    return false;
13063                                },
13064                                "".to_string()
13065                            )) == ("--")
13066                        })(&mut _diagnostic_collector),
13067                        57 => (use_global_endpoint) == (&true),
13068                        58 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13069                            let partition_resolver = &self.partition_resolver;
13070                            (region) == &mut Some(("us-east-1".to_string().into()))
13071                        })(&mut _diagnostic_collector),
13072                        59 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13073                            let bucket_arn = &context.bucket_arn;
13074                            let outpost_id_ssa_1 = &mut context.outpost_id_ssa_1;
13075                            let partition_resolver = &self.partition_resolver;
13076                            {
13077                                *outpost_id_ssa_1 = if let Some(inner) = bucket_arn {
13078                                    inner.resource_id().get(1).cloned()
13079                                } else {
13080                                    return false;
13081                                }
13082                                .map(|inner| inner.into());
13083                                outpost_id_ssa_1.is_some()
13084                            }
13085                        })(&mut _diagnostic_collector),
13086                        60 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13087                            let partition_resolver = &self.partition_resolver;
13088                            (crate::endpoint_lib::coalesce::coalesce!(use_arn_region.clone(), true)) == (true)
13089                        })(&mut _diagnostic_collector),
13090                        61 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13091                            let outpost_id_ssa_1 = &context.outpost_id_ssa_1;
13092                            let partition_resolver = &self.partition_resolver;
13093                            crate::endpoint_lib::host::is_valid_host_label(
13094                                if let Some(param) = outpost_id_ssa_1 { param } else { return false },
13095                                false,
13096                                _diagnostic_collector,
13097                            )
13098                        })(&mut _diagnostic_collector),
13099                        62 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13100                            let bucket_arn = &context.bucket_arn;
13101                            let outpost_type = &mut context.outpost_type;
13102                            let partition_resolver = &self.partition_resolver;
13103                            {
13104                                *outpost_type = if let Some(inner) = bucket_arn {
13105                                    inner.resource_id().get(2).cloned()
13106                                } else {
13107                                    return false;
13108                                }
13109                                .map(|inner| inner.into());
13110                                outpost_type.is_some()
13111                            }
13112                        })(&mut _diagnostic_collector),
13113                        63 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13114                            let bucket_arn = &context.bucket_arn;
13115                            let partition_resolver = &self.partition_resolver;
13116                            (region) == &mut Some((if let Some(inner) = bucket_arn { inner.region() } else { return false }.into()))
13117                        })(&mut _diagnostic_collector),
13118                        64 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13119                            let partition_result = &context.partition_result;
13120                            let bucket_partition = &context.bucket_partition;
13121                            let partition_resolver = &self.partition_resolver;
13122                            (if let Some(inner) = bucket_partition {
13123                                inner.name()
13124                            } else {
13125                                return false;
13126                            }) == (if let Some(inner) = partition_result {
13127                                inner.name()
13128                            } else {
13129                                return false;
13130                            })
13131                        })(&mut _diagnostic_collector),
13132                        65 => (disable_multi_region_access_points) == (&true),
13133                        66 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13134                            let bucket_arn = &context.bucket_arn;
13135                            let partition_resolver = &self.partition_resolver;
13136                            crate::endpoint_lib::host::is_valid_host_label(
13137                                if let Some(inner) = bucket_arn { inner.region() } else { return false },
13138                                true,
13139                                _diagnostic_collector,
13140                            )
13141                        })(&mut _diagnostic_collector),
13142                        67 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13143                            let partition_result = &context.partition_result;
13144                            let bucket_arn = &context.bucket_arn;
13145                            let partition_resolver = &self.partition_resolver;
13146                            (if let Some(inner) = bucket_arn { inner.partition() } else { return false })
13147                                == (if let Some(inner) = partition_result {
13148                                    inner.name()
13149                                } else {
13150                                    return false;
13151                                })
13152                        })(&mut _diagnostic_collector),
13153                        68 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13154                            let bucket_arn = &context.bucket_arn;
13155                            let partition_resolver = &self.partition_resolver;
13156                            (if let Some(inner) = bucket_arn {
13157                                inner.account_id()
13158                            } else {
13159                                return false;
13160                            }) == ("")
13161                        })(&mut _diagnostic_collector),
13162                        69 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13163                            let bucket_arn = &context.bucket_arn;
13164                            let partition_resolver = &self.partition_resolver;
13165                            (if let Some(inner) = bucket_arn { inner.service() } else { return false }) == ("s3")
13166                        })(&mut _diagnostic_collector),
13167                        70 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13168                            let bucket_arn = &context.bucket_arn;
13169                            let partition_resolver = &self.partition_resolver;
13170                            crate::endpoint_lib::host::is_valid_host_label(
13171                                if let Some(inner) = bucket_arn {
13172                                    inner.account_id()
13173                                } else {
13174                                    return false;
13175                                },
13176                                false,
13177                                _diagnostic_collector,
13178                            )
13179                        })(&mut _diagnostic_collector),
13180                        71 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13181                            let bucket_arn = &context.bucket_arn;
13182                            let access_point_name_ssa_2 = &mut context.access_point_name_ssa_2;
13183                            let partition_resolver = &self.partition_resolver;
13184                            {
13185                                *access_point_name_ssa_2 = if let Some(inner) = bucket_arn {
13186                                    inner.resource_id().get(3).cloned()
13187                                } else {
13188                                    return false;
13189                                }
13190                                .map(|inner| inner.into());
13191                                access_point_name_ssa_2.is_some()
13192                            }
13193                        })(&mut _diagnostic_collector),
13194                        72 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13195                            let access_point_name_ssa_1 = &context.access_point_name_ssa_1;
13196                            let partition_resolver = &self.partition_resolver;
13197                            crate::endpoint_lib::host::is_valid_host_label(
13198                                if let Some(param) = access_point_name_ssa_1 {
13199                                    param
13200                                } else {
13201                                    return false;
13202                                },
13203                                false,
13204                                _diagnostic_collector,
13205                            )
13206                        })(&mut _diagnostic_collector),
13207                        73 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13208                            let outpost_type = &context.outpost_type;
13209                            let partition_resolver = &self.partition_resolver;
13210                            (outpost_type) == &mut Some(("accesspoint".to_string().into()))
13211                        })(&mut _diagnostic_collector),
13212                        74 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
13213                            let access_point_name_ssa_2 = &context.access_point_name_ssa_2;
13214                            let partition_resolver = &self.partition_resolver;
13215                            crate::endpoint_lib::host::is_valid_host_label(
13216                                if let Some(param) = access_point_name_ssa_2 {
13217                                    param
13218                                } else {
13219                                    return false;
13220                                },
13221                                false,
13222                                _diagnostic_collector,
13223                            )
13224                        })(&mut _diagnostic_collector),
13225                        _ => unreachable!("Invalid condition index"),
13226                    };
13227                    current_ref = if is_complement ^ condition_result { node.high_ref } else { node.low_ref };
13228                }
13229            }
13230        }
13231    }
13232}
13233
13234impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
13235    fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
13236        // Check single-entry cache (lock-free read via ArcSwap)
13237        let cached = self.endpoint_cache.load();
13238        if let Some((cached_params, cached_endpoint)) = cached.as_ref() {
13239            if cached_params == params {
13240                return ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(::std::result::Result::Ok(cached_endpoint.clone()));
13241            }
13242        }
13243        drop(cached);
13244        let result = self.resolve_endpoint(params);
13245        if let ::std::result::Result::Ok(ref endpoint) = result {
13246            self.endpoint_cache.store(::std::sync::Arc::new(Some((params.clone(), endpoint.clone()))));
13247        }
13248        ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(result)
13249    }
13250}
13251const NODES: [crate::endpoint_lib::bdd_interpreter::BddNode; 553] = [
13252    crate::endpoint_lib::bdd_interpreter::BddNode {
13253        condition_index: -1,
13254        high_ref: 1,
13255        low_ref: -1,
13256    },
13257    crate::endpoint_lib::bdd_interpreter::BddNode {
13258        condition_index: 0,
13259        high_ref: 3,
13260        low_ref: 100000115,
13261    },
13262    crate::endpoint_lib::bdd_interpreter::BddNode {
13263        condition_index: 1,
13264        high_ref: 424,
13265        low_ref: 4,
13266    },
13267    crate::endpoint_lib::bdd_interpreter::BddNode {
13268        condition_index: 2,
13269        high_ref: 272,
13270        low_ref: 5,
13271    },
13272    crate::endpoint_lib::bdd_interpreter::BddNode {
13273        condition_index: 3,
13274        high_ref: 233,
13275        low_ref: 6,
13276    },
13277    crate::endpoint_lib::bdd_interpreter::BddNode {
13278        condition_index: 4,
13279        high_ref: 85,
13280        low_ref: 7,
13281    },
13282    crate::endpoint_lib::bdd_interpreter::BddNode {
13283        condition_index: 5,
13284        high_ref: 15,
13285        low_ref: 8,
13286    },
13287    crate::endpoint_lib::bdd_interpreter::BddNode {
13288        condition_index: 8,
13289        high_ref: 9,
13290        low_ref: 100000115,
13291    },
13292    crate::endpoint_lib::bdd_interpreter::BddNode {
13293        condition_index: 16,
13294        high_ref: 10,
13295        low_ref: 13,
13296    },
13297    crate::endpoint_lib::bdd_interpreter::BddNode {
13298        condition_index: 18,
13299        high_ref: 11,
13300        low_ref: 13,
13301    },
13302    crate::endpoint_lib::bdd_interpreter::BddNode {
13303        condition_index: 19,
13304        high_ref: 12,
13305        low_ref: 13,
13306    },
13307    crate::endpoint_lib::bdd_interpreter::BddNode {
13308        condition_index: 22,
13309        high_ref: 100000014,
13310        low_ref: 13,
13311    },
13312    crate::endpoint_lib::bdd_interpreter::BddNode {
13313        condition_index: 35,
13314        high_ref: 14,
13315        low_ref: 100000042,
13316    },
13317    crate::endpoint_lib::bdd_interpreter::BddNode {
13318        condition_index: 36,
13319        high_ref: 100000103,
13320        low_ref: 435,
13321    },
13322    crate::endpoint_lib::bdd_interpreter::BddNode {
13323        condition_index: 6,
13324        high_ref: 271,
13325        low_ref: 16,
13326    },
13327    crate::endpoint_lib::bdd_interpreter::BddNode {
13328        condition_index: 7,
13329        high_ref: 270,
13330        low_ref: 17,
13331    },
13332    crate::endpoint_lib::bdd_interpreter::BddNode {
13333        condition_index: 8,
13334        high_ref: 19,
13335        low_ref: 18,
13336    },
13337    crate::endpoint_lib::bdd_interpreter::BddNode {
13338        condition_index: 14,
13339        high_ref: 501,
13340        low_ref: 106,
13341    },
13342    crate::endpoint_lib::bdd_interpreter::BddNode {
13343        condition_index: 9,
13344        high_ref: 20,
13345        low_ref: 24,
13346    },
13347    crate::endpoint_lib::bdd_interpreter::BddNode {
13348        condition_index: 10,
13349        high_ref: 21,
13350        low_ref: 24,
13351    },
13352    crate::endpoint_lib::bdd_interpreter::BddNode {
13353        condition_index: 11,
13354        high_ref: 22,
13355        low_ref: 24,
13356    },
13357    crate::endpoint_lib::bdd_interpreter::BddNode {
13358        condition_index: 12,
13359        high_ref: 23,
13360        low_ref: 24,
13361    },
13362    crate::endpoint_lib::bdd_interpreter::BddNode {
13363        condition_index: 13,
13364        high_ref: 547,
13365        low_ref: 24,
13366    },
13367    crate::endpoint_lib::bdd_interpreter::BddNode {
13368        condition_index: 14,
13369        high_ref: 77,
13370        low_ref: 25,
13371    },
13372    crate::endpoint_lib::bdd_interpreter::BddNode {
13373        condition_index: 20,
13374        high_ref: 73,
13375        low_ref: 26,
13376    },
13377    crate::endpoint_lib::bdd_interpreter::BddNode {
13378        condition_index: 26,
13379        high_ref: 27,
13380        low_ref: 78,
13381    },
13382    crate::endpoint_lib::bdd_interpreter::BddNode {
13383        condition_index: 37,
13384        high_ref: 28,
13385        low_ref: 100000086,
13386    },
13387    crate::endpoint_lib::bdd_interpreter::BddNode {
13388        condition_index: 38,
13389        high_ref: 100000086,
13390        low_ref: 29,
13391    },
13392    crate::endpoint_lib::bdd_interpreter::BddNode {
13393        condition_index: 39,
13394        high_ref: 47,
13395        low_ref: 30,
13396    },
13397    crate::endpoint_lib::bdd_interpreter::BddNode {
13398        condition_index: 48,
13399        high_ref: 100000058,
13400        low_ref: 31,
13401    },
13402    crate::endpoint_lib::bdd_interpreter::BddNode {
13403        condition_index: 50,
13404        high_ref: 32,
13405        low_ref: 100000085,
13406    },
13407    crate::endpoint_lib::bdd_interpreter::BddNode {
13408        condition_index: 51,
13409        high_ref: 33,
13410        low_ref: 136,
13411    },
13412    crate::endpoint_lib::bdd_interpreter::BddNode {
13413        condition_index: 55,
13414        high_ref: 100000076,
13415        low_ref: 34,
13416    },
13417    crate::endpoint_lib::bdd_interpreter::BddNode {
13418        condition_index: 59,
13419        high_ref: 35,
13420        low_ref: 100000084,
13421    },
13422    crate::endpoint_lib::bdd_interpreter::BddNode {
13423        condition_index: 60,
13424        high_ref: 39,
13425        low_ref: 36,
13426    },
13427    crate::endpoint_lib::bdd_interpreter::BddNode {
13428        condition_index: 61,
13429        high_ref: 37,
13430        low_ref: 100000083,
13431    },
13432    crate::endpoint_lib::bdd_interpreter::BddNode {
13433        condition_index: 62,
13434        high_ref: 38,
13435        low_ref: 146,
13436    },
13437    crate::endpoint_lib::bdd_interpreter::BddNode {
13438        condition_index: 63,
13439        high_ref: 41,
13440        low_ref: 100000046,
13441    },
13442    crate::endpoint_lib::bdd_interpreter::BddNode {
13443        condition_index: 61,
13444        high_ref: 40,
13445        low_ref: 100000083,
13446    },
13447    crate::endpoint_lib::bdd_interpreter::BddNode {
13448        condition_index: 62,
13449        high_ref: 41,
13450        low_ref: 150,
13451    },
13452    crate::endpoint_lib::bdd_interpreter::BddNode {
13453        condition_index: 64,
13454        high_ref: 42,
13455        low_ref: 100000054,
13456    },
13457    crate::endpoint_lib::bdd_interpreter::BddNode {
13458        condition_index: 66,
13459        high_ref: 43,
13460        low_ref: 100000053,
13461    },
13462    crate::endpoint_lib::bdd_interpreter::BddNode {
13463        condition_index: 70,
13464        high_ref: 44,
13465        low_ref: 100000052,
13466    },
13467    crate::endpoint_lib::bdd_interpreter::BddNode {
13468        condition_index: 71,
13469        high_ref: 45,
13470        low_ref: 100000081,
13471    },
13472    crate::endpoint_lib::bdd_interpreter::BddNode {
13473        condition_index: 73,
13474        high_ref: 46,
13475        low_ref: 100000080,
13476    },
13477    crate::endpoint_lib::bdd_interpreter::BddNode {
13478        condition_index: 74,
13479        high_ref: 100000078,
13480        low_ref: 100000079,
13481    },
13482    crate::endpoint_lib::bdd_interpreter::BddNode {
13483        condition_index: 40,
13484        high_ref: 48,
13485        low_ref: 100000057,
13486    },
13487    crate::endpoint_lib::bdd_interpreter::BddNode {
13488        condition_index: 41,
13489        high_ref: 100000057,
13490        low_ref: 49,
13491    },
13492    crate::endpoint_lib::bdd_interpreter::BddNode {
13493        condition_index: 42,
13494        high_ref: 185,
13495        low_ref: 50,
13496    },
13497    crate::endpoint_lib::bdd_interpreter::BddNode {
13498        condition_index: 48,
13499        high_ref: 62,
13500        low_ref: 51,
13501    },
13502    crate::endpoint_lib::bdd_interpreter::BddNode {
13503        condition_index: 49,
13504        high_ref: 100000045,
13505        low_ref: 52,
13506    },
13507    crate::endpoint_lib::bdd_interpreter::BddNode {
13508        condition_index: 51,
13509        high_ref: 53,
13510        low_ref: 526,
13511    },
13512    crate::endpoint_lib::bdd_interpreter::BddNode {
13513        condition_index: 60,
13514        high_ref: 56,
13515        low_ref: 54,
13516    },
13517    crate::endpoint_lib::bdd_interpreter::BddNode {
13518        condition_index: 62,
13519        high_ref: 100000055,
13520        low_ref: 55,
13521    },
13522    crate::endpoint_lib::bdd_interpreter::BddNode {
13523        condition_index: 63,
13524        high_ref: 57,
13525        low_ref: 100000046,
13526    },
13527    crate::endpoint_lib::bdd_interpreter::BddNode {
13528        condition_index: 62,
13529        high_ref: 100000055,
13530        low_ref: 57,
13531    },
13532    crate::endpoint_lib::bdd_interpreter::BddNode {
13533        condition_index: 64,
13534        high_ref: 58,
13535        low_ref: 100000054,
13536    },
13537    crate::endpoint_lib::bdd_interpreter::BddNode {
13538        condition_index: 66,
13539        high_ref: 59,
13540        low_ref: 100000053,
13541    },
13542    crate::endpoint_lib::bdd_interpreter::BddNode {
13543        condition_index: 69,
13544        high_ref: 60,
13545        low_ref: 100000065,
13546    },
13547    crate::endpoint_lib::bdd_interpreter::BddNode {
13548        condition_index: 70,
13549        high_ref: 61,
13550        low_ref: 100000052,
13551    },
13552    crate::endpoint_lib::bdd_interpreter::BddNode {
13553        condition_index: 72,
13554        high_ref: 100000064,
13555        low_ref: 100000051,
13556    },
13557    crate::endpoint_lib::bdd_interpreter::BddNode {
13558        condition_index: 49,
13559        high_ref: 100000045,
13560        low_ref: 63,
13561    },
13562    crate::endpoint_lib::bdd_interpreter::BddNode {
13563        condition_index: 51,
13564        high_ref: 64,
13565        low_ref: 526,
13566    },
13567    crate::endpoint_lib::bdd_interpreter::BddNode {
13568        condition_index: 60,
13569        high_ref: 67,
13570        low_ref: 65,
13571    },
13572    crate::endpoint_lib::bdd_interpreter::BddNode {
13573        condition_index: 62,
13574        high_ref: 100000055,
13575        low_ref: 66,
13576    },
13577    crate::endpoint_lib::bdd_interpreter::BddNode {
13578        condition_index: 63,
13579        high_ref: 68,
13580        low_ref: 100000046,
13581    },
13582    crate::endpoint_lib::bdd_interpreter::BddNode {
13583        condition_index: 62,
13584        high_ref: 100000055,
13585        low_ref: 68,
13586    },
13587    crate::endpoint_lib::bdd_interpreter::BddNode {
13588        condition_index: 64,
13589        high_ref: 69,
13590        low_ref: 100000054,
13591    },
13592    crate::endpoint_lib::bdd_interpreter::BddNode {
13593        condition_index: 66,
13594        high_ref: 70,
13595        low_ref: 100000053,
13596    },
13597    crate::endpoint_lib::bdd_interpreter::BddNode {
13598        condition_index: 68,
13599        high_ref: 100000047,
13600        low_ref: 71,
13601    },
13602    crate::endpoint_lib::bdd_interpreter::BddNode {
13603        condition_index: 70,
13604        high_ref: 72,
13605        low_ref: 100000052,
13606    },
13607    crate::endpoint_lib::bdd_interpreter::BddNode {
13608        condition_index: 72,
13609        high_ref: 100000050,
13610        low_ref: 100000051,
13611    },
13612    crate::endpoint_lib::bdd_interpreter::BddNode {
13613        condition_index: 25,
13614        high_ref: 74,
13615        low_ref: 100000042,
13616    },
13617    crate::endpoint_lib::bdd_interpreter::BddNode {
13618        condition_index: 46,
13619        high_ref: 100000039,
13620        low_ref: 75,
13621    },
13622    crate::endpoint_lib::bdd_interpreter::BddNode {
13623        condition_index: 57,
13624        high_ref: 76,
13625        low_ref: 100000041,
13626    },
13627    crate::endpoint_lib::bdd_interpreter::BddNode {
13628        condition_index: 58,
13629        high_ref: 100000040,
13630        low_ref: 100000041,
13631    },
13632    crate::endpoint_lib::bdd_interpreter::BddNode {
13633        condition_index: 26,
13634        high_ref: 100000088,
13635        low_ref: 78,
13636    },
13637    crate::endpoint_lib::bdd_interpreter::BddNode {
13638        condition_index: 28,
13639        high_ref: 100000087,
13640        low_ref: 79,
13641    },
13642    crate::endpoint_lib::bdd_interpreter::BddNode {
13643        condition_index: 34,
13644        high_ref: 82,
13645        low_ref: 80,
13646    },
13647    crate::endpoint_lib::bdd_interpreter::BddNode {
13648        condition_index: 35,
13649        high_ref: 81,
13650        low_ref: 545,
13651    },
13652    crate::endpoint_lib::bdd_interpreter::BddNode {
13653        condition_index: 36,
13654        high_ref: 100000103,
13655        low_ref: 100000115,
13656    },
13657    crate::endpoint_lib::bdd_interpreter::BddNode {
13658        condition_index: 46,
13659        high_ref: 100000097,
13660        low_ref: 83,
13661    },
13662    crate::endpoint_lib::bdd_interpreter::BddNode {
13663        condition_index: 57,
13664        high_ref: 84,
13665        low_ref: 100000099,
13666    },
13667    crate::endpoint_lib::bdd_interpreter::BddNode {
13668        condition_index: 58,
13669        high_ref: 100000098,
13670        low_ref: 100000099,
13671    },
13672    crate::endpoint_lib::bdd_interpreter::BddNode {
13673        condition_index: 5,
13674        high_ref: 101,
13675        low_ref: 86,
13676    },
13677    crate::endpoint_lib::bdd_interpreter::BddNode {
13678        condition_index: 8,
13679        high_ref: 87,
13680        low_ref: 100000115,
13681    },
13682    crate::endpoint_lib::bdd_interpreter::BddNode {
13683        condition_index: 16,
13684        high_ref: 88,
13685        low_ref: 89,
13686    },
13687    crate::endpoint_lib::bdd_interpreter::BddNode {
13688        condition_index: 18,
13689        high_ref: 91,
13690        low_ref: 89,
13691    },
13692    crate::endpoint_lib::bdd_interpreter::BddNode {
13693        condition_index: 19,
13694        high_ref: 90,
13695        low_ref: 92,
13696    },
13697    crate::endpoint_lib::bdd_interpreter::BddNode {
13698        condition_index: 21,
13699        high_ref: 97,
13700        low_ref: 95,
13701    },
13702    crate::endpoint_lib::bdd_interpreter::BddNode {
13703        condition_index: 19,
13704        high_ref: 93,
13705        low_ref: 92,
13706    },
13707    crate::endpoint_lib::bdd_interpreter::BddNode {
13708        condition_index: 21,
13709        high_ref: 98,
13710        low_ref: 95,
13711    },
13712    crate::endpoint_lib::bdd_interpreter::BddNode {
13713        condition_index: 21,
13714        high_ref: 97,
13715        low_ref: 94,
13716    },
13717    crate::endpoint_lib::bdd_interpreter::BddNode {
13718        condition_index: 22,
13719        high_ref: 100000014,
13720        low_ref: 95,
13721    },
13722    crate::endpoint_lib::bdd_interpreter::BddNode {
13723        condition_index: 35,
13724        high_ref: 96,
13725        low_ref: 100000042,
13726    },
13727    crate::endpoint_lib::bdd_interpreter::BddNode {
13728        condition_index: 36,
13729        high_ref: 100000103,
13730        low_ref: 100000042,
13731    },
13732    crate::endpoint_lib::bdd_interpreter::BddNode {
13733        condition_index: 22,
13734        high_ref: 100000013,
13735        low_ref: 98,
13736    },
13737    crate::endpoint_lib::bdd_interpreter::BddNode {
13738        condition_index: 35,
13739        high_ref: 99,
13740        low_ref: 100000042,
13741    },
13742    crate::endpoint_lib::bdd_interpreter::BddNode {
13743        condition_index: 36,
13744        high_ref: 100000101,
13745        low_ref: 100,
13746    },
13747    crate::endpoint_lib::bdd_interpreter::BddNode {
13748        condition_index: 46,
13749        high_ref: 100000110,
13750        low_ref: 100000111,
13751    },
13752    crate::endpoint_lib::bdd_interpreter::BddNode {
13753        condition_index: 6,
13754        high_ref: 214,
13755        low_ref: 102,
13756    },
13757    crate::endpoint_lib::bdd_interpreter::BddNode {
13758        condition_index: 7,
13759        high_ref: 208,
13760        low_ref: 103,
13761    },
13762    crate::endpoint_lib::bdd_interpreter::BddNode {
13763        condition_index: 8,
13764        high_ref: 119,
13765        low_ref: 104,
13766    },
13767    crate::endpoint_lib::bdd_interpreter::BddNode {
13768        condition_index: 14,
13769        high_ref: 118,
13770        low_ref: 105,
13771    },
13772    crate::endpoint_lib::bdd_interpreter::BddNode {
13773        condition_index: 21,
13774        high_ref: 106,
13775        low_ref: 100000023,
13776    },
13777    crate::endpoint_lib::bdd_interpreter::BddNode {
13778        condition_index: 26,
13779        high_ref: 107,
13780        low_ref: 502,
13781    },
13782    crate::endpoint_lib::bdd_interpreter::BddNode {
13783        condition_index: 37,
13784        high_ref: 108,
13785        low_ref: 100000086,
13786    },
13787    crate::endpoint_lib::bdd_interpreter::BddNode {
13788        condition_index: 38,
13789        high_ref: 100000086,
13790        low_ref: 109,
13791    },
13792    crate::endpoint_lib::bdd_interpreter::BddNode {
13793        condition_index: 39,
13794        high_ref: 112,
13795        low_ref: 110,
13796    },
13797    crate::endpoint_lib::bdd_interpreter::BddNode {
13798        condition_index: 48,
13799        high_ref: 100000058,
13800        low_ref: 111,
13801    },
13802    crate::endpoint_lib::bdd_interpreter::BddNode {
13803        condition_index: 50,
13804        high_ref: 136,
13805        low_ref: 100000085,
13806    },
13807    crate::endpoint_lib::bdd_interpreter::BddNode {
13808        condition_index: 40,
13809        high_ref: 113,
13810        low_ref: 100000057,
13811    },
13812    crate::endpoint_lib::bdd_interpreter::BddNode {
13813        condition_index: 41,
13814        high_ref: 100000057,
13815        low_ref: 114,
13816    },
13817    crate::endpoint_lib::bdd_interpreter::BddNode {
13818        condition_index: 42,
13819        high_ref: 115,
13820        low_ref: 500,
13821    },
13822    crate::endpoint_lib::bdd_interpreter::BddNode {
13823        condition_index: 48,
13824        high_ref: 100000056,
13825        low_ref: 116,
13826    },
13827    crate::endpoint_lib::bdd_interpreter::BddNode {
13828        condition_index: 52,
13829        high_ref: 117,
13830        low_ref: 100000072,
13831    },
13832    crate::endpoint_lib::bdd_interpreter::BddNode {
13833        condition_index: 65,
13834        high_ref: 100000069,
13835        low_ref: 100000072,
13836    },
13837    crate::endpoint_lib::bdd_interpreter::BddNode {
13838        condition_index: 21,
13839        high_ref: 501,
13840        low_ref: 100000023,
13841    },
13842    crate::endpoint_lib::bdd_interpreter::BddNode {
13843        condition_index: 9,
13844        high_ref: 120,
13845        low_ref: 124,
13846    },
13847    crate::endpoint_lib::bdd_interpreter::BddNode {
13848        condition_index: 10,
13849        high_ref: 121,
13850        low_ref: 124,
13851    },
13852    crate::endpoint_lib::bdd_interpreter::BddNode {
13853        condition_index: 11,
13854        high_ref: 122,
13855        low_ref: 124,
13856    },
13857    crate::endpoint_lib::bdd_interpreter::BddNode {
13858        condition_index: 12,
13859        high_ref: 123,
13860        low_ref: 124,
13861    },
13862    crate::endpoint_lib::bdd_interpreter::BddNode {
13863        condition_index: 13,
13864        high_ref: 202,
13865        low_ref: 124,
13866    },
13867    crate::endpoint_lib::bdd_interpreter::BddNode {
13868        condition_index: 14,
13869        high_ref: 195,
13870        low_ref: 125,
13871    },
13872    crate::endpoint_lib::bdd_interpreter::BddNode {
13873        condition_index: 20,
13874        high_ref: 190,
13875        low_ref: 126,
13876    },
13877    crate::endpoint_lib::bdd_interpreter::BddNode {
13878        condition_index: 21,
13879        high_ref: 127,
13880        low_ref: 100000023,
13881    },
13882    crate::endpoint_lib::bdd_interpreter::BddNode {
13883        condition_index: 23,
13884        high_ref: 128,
13885        low_ref: 129,
13886    },
13887    crate::endpoint_lib::bdd_interpreter::BddNode {
13888        condition_index: 24,
13889        high_ref: 189,
13890        low_ref: 129,
13891    },
13892    crate::endpoint_lib::bdd_interpreter::BddNode {
13893        condition_index: 26,
13894        high_ref: 130,
13895        low_ref: 197,
13896    },
13897    crate::endpoint_lib::bdd_interpreter::BddNode {
13898        condition_index: 37,
13899        high_ref: 131,
13900        low_ref: 100000086,
13901    },
13902    crate::endpoint_lib::bdd_interpreter::BddNode {
13903        condition_index: 38,
13904        high_ref: 100000086,
13905        low_ref: 132,
13906    },
13907    crate::endpoint_lib::bdd_interpreter::BddNode {
13908        condition_index: 39,
13909        high_ref: 159,
13910        low_ref: 133,
13911    },
13912    crate::endpoint_lib::bdd_interpreter::BddNode {
13913        condition_index: 48,
13914        high_ref: 100000058,
13915        low_ref: 134,
13916    },
13917    crate::endpoint_lib::bdd_interpreter::BddNode {
13918        condition_index: 50,
13919        high_ref: 135,
13920        low_ref: 100000085,
13921    },
13922    crate::endpoint_lib::bdd_interpreter::BddNode {
13923        condition_index: 51,
13924        high_ref: 141,
13925        low_ref: 136,
13926    },
13927    crate::endpoint_lib::bdd_interpreter::BddNode {
13928        condition_index: 55,
13929        high_ref: 100000076,
13930        low_ref: 137,
13931    },
13932    crate::endpoint_lib::bdd_interpreter::BddNode {
13933        condition_index: 59,
13934        high_ref: 138,
13935        low_ref: 100000084,
13936    },
13937    crate::endpoint_lib::bdd_interpreter::BddNode {
13938        condition_index: 60,
13939        high_ref: 100000083,
13940        low_ref: 139,
13941    },
13942    crate::endpoint_lib::bdd_interpreter::BddNode {
13943        condition_index: 61,
13944        high_ref: 140,
13945        low_ref: 100000083,
13946    },
13947    crate::endpoint_lib::bdd_interpreter::BddNode {
13948        condition_index: 63,
13949        high_ref: 100000083,
13950        low_ref: 100000046,
13951    },
13952    crate::endpoint_lib::bdd_interpreter::BddNode {
13953        condition_index: 55,
13954        high_ref: 100000076,
13955        low_ref: 142,
13956    },
13957    crate::endpoint_lib::bdd_interpreter::BddNode {
13958        condition_index: 59,
13959        high_ref: 143,
13960        low_ref: 100000084,
13961    },
13962    crate::endpoint_lib::bdd_interpreter::BddNode {
13963        condition_index: 60,
13964        high_ref: 148,
13965        low_ref: 144,
13966    },
13967    crate::endpoint_lib::bdd_interpreter::BddNode {
13968        condition_index: 61,
13969        high_ref: 145,
13970        low_ref: 100000083,
13971    },
13972    crate::endpoint_lib::bdd_interpreter::BddNode {
13973        condition_index: 62,
13974        high_ref: 147,
13975        low_ref: 146,
13976    },
13977    crate::endpoint_lib::bdd_interpreter::BddNode {
13978        condition_index: 63,
13979        high_ref: 150,
13980        low_ref: 100000046,
13981    },
13982    crate::endpoint_lib::bdd_interpreter::BddNode {
13983        condition_index: 63,
13984        high_ref: 153,
13985        low_ref: 100000046,
13986    },
13987    crate::endpoint_lib::bdd_interpreter::BddNode {
13988        condition_index: 61,
13989        high_ref: 149,
13990        low_ref: 100000083,
13991    },
13992    crate::endpoint_lib::bdd_interpreter::BddNode {
13993        condition_index: 62,
13994        high_ref: 153,
13995        low_ref: 150,
13996    },
13997    crate::endpoint_lib::bdd_interpreter::BddNode {
13998        condition_index: 64,
13999        high_ref: 151,
14000        low_ref: 100000054,
14001    },
14002    crate::endpoint_lib::bdd_interpreter::BddNode {
14003        condition_index: 66,
14004        high_ref: 152,
14005        low_ref: 100000053,
14006    },
14007    crate::endpoint_lib::bdd_interpreter::BddNode {
14008        condition_index: 70,
14009        high_ref: 100000082,
14010        low_ref: 100000052,
14011    },
14012    crate::endpoint_lib::bdd_interpreter::BddNode {
14013        condition_index: 64,
14014        high_ref: 154,
14015        low_ref: 100000054,
14016    },
14017    crate::endpoint_lib::bdd_interpreter::BddNode {
14018        condition_index: 66,
14019        high_ref: 155,
14020        low_ref: 100000053,
14021    },
14022    crate::endpoint_lib::bdd_interpreter::BddNode {
14023        condition_index: 70,
14024        high_ref: 156,
14025        low_ref: 100000052,
14026    },
14027    crate::endpoint_lib::bdd_interpreter::BddNode {
14028        condition_index: 71,
14029        high_ref: 157,
14030        low_ref: 100000081,
14031    },
14032    crate::endpoint_lib::bdd_interpreter::BddNode {
14033        condition_index: 73,
14034        high_ref: 158,
14035        low_ref: 100000080,
14036    },
14037    crate::endpoint_lib::bdd_interpreter::BddNode {
14038        condition_index: 74,
14039        high_ref: 100000077,
14040        low_ref: 100000079,
14041    },
14042    crate::endpoint_lib::bdd_interpreter::BddNode {
14043        condition_index: 40,
14044        high_ref: 160,
14045        low_ref: 100000057,
14046    },
14047    crate::endpoint_lib::bdd_interpreter::BddNode {
14048        condition_index: 41,
14049        high_ref: 100000057,
14050        low_ref: 161,
14051    },
14052    crate::endpoint_lib::bdd_interpreter::BddNode {
14053        condition_index: 42,
14054        high_ref: 185,
14055        low_ref: 162,
14056    },
14057    crate::endpoint_lib::bdd_interpreter::BddNode {
14058        condition_index: 48,
14059        high_ref: 174,
14060        low_ref: 163,
14061    },
14062    crate::endpoint_lib::bdd_interpreter::BddNode {
14063        condition_index: 49,
14064        high_ref: 100000045,
14065        low_ref: 164,
14066    },
14067    crate::endpoint_lib::bdd_interpreter::BddNode {
14068        condition_index: 51,
14069        high_ref: 165,
14070        low_ref: 526,
14071    },
14072    crate::endpoint_lib::bdd_interpreter::BddNode {
14073        condition_index: 60,
14074        high_ref: 168,
14075        low_ref: 166,
14076    },
14077    crate::endpoint_lib::bdd_interpreter::BddNode {
14078        condition_index: 62,
14079        high_ref: 100000055,
14080        low_ref: 167,
14081    },
14082    crate::endpoint_lib::bdd_interpreter::BddNode {
14083        condition_index: 63,
14084        high_ref: 169,
14085        low_ref: 100000046,
14086    },
14087    crate::endpoint_lib::bdd_interpreter::BddNode {
14088        condition_index: 62,
14089        high_ref: 100000055,
14090        low_ref: 169,
14091    },
14092    crate::endpoint_lib::bdd_interpreter::BddNode {
14093        condition_index: 64,
14094        high_ref: 170,
14095        low_ref: 100000054,
14096    },
14097    crate::endpoint_lib::bdd_interpreter::BddNode {
14098        condition_index: 66,
14099        high_ref: 171,
14100        low_ref: 100000053,
14101    },
14102    crate::endpoint_lib::bdd_interpreter::BddNode {
14103        condition_index: 69,
14104        high_ref: 172,
14105        low_ref: 100000065,
14106    },
14107    crate::endpoint_lib::bdd_interpreter::BddNode {
14108        condition_index: 70,
14109        high_ref: 173,
14110        low_ref: 100000052,
14111    },
14112    crate::endpoint_lib::bdd_interpreter::BddNode {
14113        condition_index: 72,
14114        high_ref: 100000063,
14115        low_ref: 100000051,
14116    },
14117    crate::endpoint_lib::bdd_interpreter::BddNode {
14118        condition_index: 49,
14119        high_ref: 100000045,
14120        low_ref: 175,
14121    },
14122    crate::endpoint_lib::bdd_interpreter::BddNode {
14123        condition_index: 51,
14124        high_ref: 176,
14125        low_ref: 526,
14126    },
14127    crate::endpoint_lib::bdd_interpreter::BddNode {
14128        condition_index: 60,
14129        high_ref: 179,
14130        low_ref: 177,
14131    },
14132    crate::endpoint_lib::bdd_interpreter::BddNode {
14133        condition_index: 62,
14134        high_ref: 100000055,
14135        low_ref: 178,
14136    },
14137    crate::endpoint_lib::bdd_interpreter::BddNode {
14138        condition_index: 63,
14139        high_ref: 180,
14140        low_ref: 100000046,
14141    },
14142    crate::endpoint_lib::bdd_interpreter::BddNode {
14143        condition_index: 62,
14144        high_ref: 100000055,
14145        low_ref: 180,
14146    },
14147    crate::endpoint_lib::bdd_interpreter::BddNode {
14148        condition_index: 64,
14149        high_ref: 181,
14150        low_ref: 100000054,
14151    },
14152    crate::endpoint_lib::bdd_interpreter::BddNode {
14153        condition_index: 66,
14154        high_ref: 182,
14155        low_ref: 100000053,
14156    },
14157    crate::endpoint_lib::bdd_interpreter::BddNode {
14158        condition_index: 68,
14159        high_ref: 100000047,
14160        low_ref: 183,
14161    },
14162    crate::endpoint_lib::bdd_interpreter::BddNode {
14163        condition_index: 70,
14164        high_ref: 184,
14165        low_ref: 100000052,
14166    },
14167    crate::endpoint_lib::bdd_interpreter::BddNode {
14168        condition_index: 72,
14169        high_ref: 100000048,
14170        low_ref: 100000051,
14171    },
14172    crate::endpoint_lib::bdd_interpreter::BddNode {
14173        condition_index: 48,
14174        high_ref: 100000056,
14175        low_ref: 186,
14176    },
14177    crate::endpoint_lib::bdd_interpreter::BddNode {
14178        condition_index: 52,
14179        high_ref: 187,
14180        low_ref: 100000072,
14181    },
14182    crate::endpoint_lib::bdd_interpreter::BddNode {
14183        condition_index: 65,
14184        high_ref: 100000069,
14185        low_ref: 188,
14186    },
14187    crate::endpoint_lib::bdd_interpreter::BddNode {
14188        condition_index: 67,
14189        high_ref: 100000070,
14190        low_ref: 100000071,
14191    },
14192    crate::endpoint_lib::bdd_interpreter::BddNode {
14193        condition_index: 25,
14194        high_ref: 100000036,
14195        low_ref: 100000042,
14196    },
14197    crate::endpoint_lib::bdd_interpreter::BddNode {
14198        condition_index: 21,
14199        high_ref: 191,
14200        low_ref: 100000023,
14201    },
14202    crate::endpoint_lib::bdd_interpreter::BddNode {
14203        condition_index: 25,
14204        high_ref: 192,
14205        low_ref: 100000042,
14206    },
14207    crate::endpoint_lib::bdd_interpreter::BddNode {
14208        condition_index: 30,
14209        high_ref: 194,
14210        low_ref: 193,
14211    },
14212    crate::endpoint_lib::bdd_interpreter::BddNode {
14213        condition_index: 46,
14214        high_ref: 100000034,
14215        low_ref: 100000036,
14216    },
14217    crate::endpoint_lib::bdd_interpreter::BddNode {
14218        condition_index: 46,
14219        high_ref: 100000033,
14220        low_ref: 100000035,
14221    },
14222    crate::endpoint_lib::bdd_interpreter::BddNode {
14223        condition_index: 21,
14224        high_ref: 196,
14225        low_ref: 100000023,
14226    },
14227    crate::endpoint_lib::bdd_interpreter::BddNode {
14228        condition_index: 26,
14229        high_ref: 100000088,
14230        low_ref: 197,
14231    },
14232    crate::endpoint_lib::bdd_interpreter::BddNode {
14233        condition_index: 28,
14234        high_ref: 100000087,
14235        low_ref: 198,
14236    },
14237    crate::endpoint_lib::bdd_interpreter::BddNode {
14238        condition_index: 34,
14239        high_ref: 201,
14240        low_ref: 199,
14241    },
14242    crate::endpoint_lib::bdd_interpreter::BddNode {
14243        condition_index: 35,
14244        high_ref: 200,
14245        low_ref: 545,
14246    },
14247    crate::endpoint_lib::bdd_interpreter::BddNode {
14248        condition_index: 36,
14249        high_ref: 100000101,
14250        low_ref: 100000115,
14251    },
14252    crate::endpoint_lib::bdd_interpreter::BddNode {
14253        condition_index: 46,
14254        high_ref: 100000095,
14255        low_ref: 100000096,
14256    },
14257    crate::endpoint_lib::bdd_interpreter::BddNode {
14258        condition_index: 17,
14259        high_ref: 203,
14260        low_ref: 100000022,
14261    },
14262    crate::endpoint_lib::bdd_interpreter::BddNode {
14263        condition_index: 20,
14264        high_ref: 204,
14265        low_ref: 100000021,
14266    },
14267    crate::endpoint_lib::bdd_interpreter::BddNode {
14268        condition_index: 21,
14269        high_ref: 205,
14270        low_ref: 550,
14271    },
14272    crate::endpoint_lib::bdd_interpreter::BddNode {
14273        condition_index: 33,
14274        high_ref: 206,
14275        low_ref: 550,
14276    },
14277    crate::endpoint_lib::bdd_interpreter::BddNode {
14278        condition_index: 44,
14279        high_ref: 100000016,
14280        low_ref: 207,
14281    },
14282    crate::endpoint_lib::bdd_interpreter::BddNode {
14283        condition_index: 45,
14284        high_ref: 100000018,
14285        low_ref: 100000020,
14286    },
14287    crate::endpoint_lib::bdd_interpreter::BddNode {
14288        condition_index: 8,
14289        high_ref: 209,
14290        low_ref: 215,
14291    },
14292    crate::endpoint_lib::bdd_interpreter::BddNode {
14293        condition_index: 16,
14294        high_ref: 210,
14295        low_ref: 220,
14296    },
14297    crate::endpoint_lib::bdd_interpreter::BddNode {
14298        condition_index: 18,
14299        high_ref: 211,
14300        low_ref: 220,
14301    },
14302    crate::endpoint_lib::bdd_interpreter::BddNode {
14303        condition_index: 19,
14304        high_ref: 212,
14305        low_ref: 224,
14306    },
14307    crate::endpoint_lib::bdd_interpreter::BddNode {
14308        condition_index: 20,
14309        high_ref: 213,
14310        low_ref: 227,
14311    },
14312    crate::endpoint_lib::bdd_interpreter::BddNode {
14313        condition_index: 21,
14314        high_ref: 231,
14315        low_ref: 401,
14316    },
14317    crate::endpoint_lib::bdd_interpreter::BddNode {
14318        condition_index: 8,
14319        high_ref: 218,
14320        low_ref: 215,
14321    },
14322    crate::endpoint_lib::bdd_interpreter::BddNode {
14323        condition_index: 19,
14324        high_ref: 216,
14325        low_ref: 100000009,
14326    },
14327    crate::endpoint_lib::bdd_interpreter::BddNode {
14328        condition_index: 20,
14329        high_ref: 217,
14330        low_ref: 227,
14331    },
14332    crate::endpoint_lib::bdd_interpreter::BddNode {
14333        condition_index: 21,
14334        high_ref: 231,
14335        low_ref: 100000009,
14336    },
14337    crate::endpoint_lib::bdd_interpreter::BddNode {
14338        condition_index: 16,
14339        high_ref: 219,
14340        low_ref: 220,
14341    },
14342    crate::endpoint_lib::bdd_interpreter::BddNode {
14343        condition_index: 18,
14344        high_ref: 223,
14345        low_ref: 220,
14346    },
14347    crate::endpoint_lib::bdd_interpreter::BddNode {
14348        condition_index: 19,
14349        high_ref: 221,
14350        low_ref: 224,
14351    },
14352    crate::endpoint_lib::bdd_interpreter::BddNode {
14353        condition_index: 20,
14354        high_ref: 222,
14355        low_ref: 227,
14356    },
14357    crate::endpoint_lib::bdd_interpreter::BddNode {
14358        condition_index: 21,
14359        high_ref: 231,
14360        low_ref: 100000012,
14361    },
14362    crate::endpoint_lib::bdd_interpreter::BddNode {
14363        condition_index: 19,
14364        high_ref: 226,
14365        low_ref: 224,
14366    },
14367    crate::endpoint_lib::bdd_interpreter::BddNode {
14368        condition_index: 20,
14369        high_ref: 225,
14370        low_ref: 100000009,
14371    },
14372    crate::endpoint_lib::bdd_interpreter::BddNode {
14373        condition_index: 21,
14374        high_ref: 100000009,
14375        low_ref: 100000012,
14376    },
14377    crate::endpoint_lib::bdd_interpreter::BddNode {
14378        condition_index: 20,
14379        high_ref: 230,
14380        low_ref: 227,
14381    },
14382    crate::endpoint_lib::bdd_interpreter::BddNode {
14383        condition_index: 21,
14384        high_ref: 228,
14385        low_ref: 100000009,
14386    },
14387    crate::endpoint_lib::bdd_interpreter::BddNode {
14388        condition_index: 30,
14389        high_ref: 229,
14390        low_ref: 100000009,
14391    },
14392    crate::endpoint_lib::bdd_interpreter::BddNode {
14393        condition_index: 34,
14394        high_ref: 100000007,
14395        low_ref: 100000009,
14396    },
14397    crate::endpoint_lib::bdd_interpreter::BddNode {
14398        condition_index: 21,
14399        high_ref: 231,
14400        low_ref: 415,
14401    },
14402    crate::endpoint_lib::bdd_interpreter::BddNode {
14403        condition_index: 30,
14404        high_ref: 232,
14405        low_ref: 100000008,
14406    },
14407    crate::endpoint_lib::bdd_interpreter::BddNode {
14408        condition_index: 34,
14409        high_ref: 100000007,
14410        low_ref: 100000008,
14411    },
14412    crate::endpoint_lib::bdd_interpreter::BddNode {
14413        condition_index: 4,
14414        high_ref: 100000002,
14415        low_ref: 234,
14416    },
14417    crate::endpoint_lib::bdd_interpreter::BddNode {
14418        condition_index: 5,
14419        high_ref: 235,
14420        low_ref: 480,
14421    },
14422    crate::endpoint_lib::bdd_interpreter::BddNode {
14423        condition_index: 6,
14424        high_ref: 271,
14425        low_ref: 236,
14426    },
14427    crate::endpoint_lib::bdd_interpreter::BddNode {
14428        condition_index: 7,
14429        high_ref: 270,
14430        low_ref: 237,
14431    },
14432    crate::endpoint_lib::bdd_interpreter::BddNode {
14433        condition_index: 8,
14434        high_ref: 238,
14435        low_ref: 491,
14436    },
14437    crate::endpoint_lib::bdd_interpreter::BddNode {
14438        condition_index: 9,
14439        high_ref: 239,
14440        low_ref: 243,
14441    },
14442    crate::endpoint_lib::bdd_interpreter::BddNode {
14443        condition_index: 10,
14444        high_ref: 240,
14445        low_ref: 243,
14446    },
14447    crate::endpoint_lib::bdd_interpreter::BddNode {
14448        condition_index: 11,
14449        high_ref: 241,
14450        low_ref: 243,
14451    },
14452    crate::endpoint_lib::bdd_interpreter::BddNode {
14453        condition_index: 12,
14454        high_ref: 242,
14455        low_ref: 243,
14456    },
14457    crate::endpoint_lib::bdd_interpreter::BddNode {
14458        condition_index: 13,
14459        high_ref: 547,
14460        low_ref: 243,
14461    },
14462    crate::endpoint_lib::bdd_interpreter::BddNode {
14463        condition_index: 14,
14464        high_ref: 266,
14465        low_ref: 244,
14466    },
14467    crate::endpoint_lib::bdd_interpreter::BddNode {
14468        condition_index: 20,
14469        high_ref: 264,
14470        low_ref: 245,
14471    },
14472    crate::endpoint_lib::bdd_interpreter::BddNode {
14473        condition_index: 26,
14474        high_ref: 246,
14475        low_ref: 267,
14476    },
14477    crate::endpoint_lib::bdd_interpreter::BddNode {
14478        condition_index: 37,
14479        high_ref: 247,
14480        low_ref: 100000086,
14481    },
14482    crate::endpoint_lib::bdd_interpreter::BddNode {
14483        condition_index: 38,
14484        high_ref: 100000086,
14485        low_ref: 248,
14486    },
14487    crate::endpoint_lib::bdd_interpreter::BddNode {
14488        condition_index: 39,
14489        high_ref: 249,
14490        low_ref: 518,
14491    },
14492    crate::endpoint_lib::bdd_interpreter::BddNode {
14493        condition_index: 40,
14494        high_ref: 250,
14495        low_ref: 100000057,
14496    },
14497    crate::endpoint_lib::bdd_interpreter::BddNode {
14498        condition_index: 41,
14499        high_ref: 100000057,
14500        low_ref: 251,
14501    },
14502    crate::endpoint_lib::bdd_interpreter::BddNode {
14503        condition_index: 42,
14504        high_ref: 538,
14505        low_ref: 252,
14506    },
14507    crate::endpoint_lib::bdd_interpreter::BddNode {
14508        condition_index: 48,
14509        high_ref: 100000043,
14510        low_ref: 253,
14511    },
14512    crate::endpoint_lib::bdd_interpreter::BddNode {
14513        condition_index: 49,
14514        high_ref: 100000045,
14515        low_ref: 254,
14516    },
14517    crate::endpoint_lib::bdd_interpreter::BddNode {
14518        condition_index: 51,
14519        high_ref: 255,
14520        low_ref: 526,
14521    },
14522    crate::endpoint_lib::bdd_interpreter::BddNode {
14523        condition_index: 60,
14524        high_ref: 258,
14525        low_ref: 256,
14526    },
14527    crate::endpoint_lib::bdd_interpreter::BddNode {
14528        condition_index: 62,
14529        high_ref: 100000055,
14530        low_ref: 257,
14531    },
14532    crate::endpoint_lib::bdd_interpreter::BddNode {
14533        condition_index: 63,
14534        high_ref: 259,
14535        low_ref: 100000046,
14536    },
14537    crate::endpoint_lib::bdd_interpreter::BddNode {
14538        condition_index: 62,
14539        high_ref: 100000055,
14540        low_ref: 259,
14541    },
14542    crate::endpoint_lib::bdd_interpreter::BddNode {
14543        condition_index: 64,
14544        high_ref: 260,
14545        low_ref: 100000054,
14546    },
14547    crate::endpoint_lib::bdd_interpreter::BddNode {
14548        condition_index: 66,
14549        high_ref: 261,
14550        low_ref: 100000053,
14551    },
14552    crate::endpoint_lib::bdd_interpreter::BddNode {
14553        condition_index: 69,
14554        high_ref: 262,
14555        low_ref: 100000065,
14556    },
14557    crate::endpoint_lib::bdd_interpreter::BddNode {
14558        condition_index: 70,
14559        high_ref: 263,
14560        low_ref: 100000052,
14561    },
14562    crate::endpoint_lib::bdd_interpreter::BddNode {
14563        condition_index: 72,
14564        high_ref: 100000062,
14565        low_ref: 100000051,
14566    },
14567    crate::endpoint_lib::bdd_interpreter::BddNode {
14568        condition_index: 25,
14569        high_ref: 265,
14570        low_ref: 100000042,
14571    },
14572    crate::endpoint_lib::bdd_interpreter::BddNode {
14573        condition_index: 46,
14574        high_ref: 100000031,
14575        low_ref: 100000032,
14576    },
14577    crate::endpoint_lib::bdd_interpreter::BddNode {
14578        condition_index: 26,
14579        high_ref: 100000088,
14580        low_ref: 267,
14581    },
14582    crate::endpoint_lib::bdd_interpreter::BddNode {
14583        condition_index: 28,
14584        high_ref: 100000087,
14585        low_ref: 268,
14586    },
14587    crate::endpoint_lib::bdd_interpreter::BddNode {
14588        condition_index: 34,
14589        high_ref: 269,
14590        low_ref: 544,
14591    },
14592    crate::endpoint_lib::bdd_interpreter::BddNode {
14593        condition_index: 46,
14594        high_ref: 100000093,
14595        low_ref: 100000094,
14596    },
14597    crate::endpoint_lib::bdd_interpreter::BddNode {
14598        condition_index: 8,
14599        high_ref: 397,
14600        low_ref: 100000009,
14601    },
14602    crate::endpoint_lib::bdd_interpreter::BddNode {
14603        condition_index: 8,
14604        high_ref: 407,
14605        low_ref: 100000009,
14606    },
14607    crate::endpoint_lib::bdd_interpreter::BddNode {
14608        condition_index: 3,
14609        high_ref: 346,
14610        low_ref: 273,
14611    },
14612    crate::endpoint_lib::bdd_interpreter::BddNode {
14613        condition_index: 4,
14614        high_ref: 100000003,
14615        low_ref: 274,
14616    },
14617    crate::endpoint_lib::bdd_interpreter::BddNode {
14618        condition_index: 5,
14619        high_ref: 284,
14620        low_ref: 275,
14621    },
14622    crate::endpoint_lib::bdd_interpreter::BddNode {
14623        condition_index: 8,
14624        high_ref: 276,
14625        low_ref: 100000115,
14626    },
14627    crate::endpoint_lib::bdd_interpreter::BddNode {
14628        condition_index: 15,
14629        high_ref: 100000005,
14630        low_ref: 277,
14631    },
14632    crate::endpoint_lib::bdd_interpreter::BddNode {
14633        condition_index: 16,
14634        high_ref: 278,
14635        low_ref: 281,
14636    },
14637    crate::endpoint_lib::bdd_interpreter::BddNode {
14638        condition_index: 18,
14639        high_ref: 279,
14640        low_ref: 281,
14641    },
14642    crate::endpoint_lib::bdd_interpreter::BddNode {
14643        condition_index: 19,
14644        high_ref: 280,
14645        low_ref: 281,
14646    },
14647    crate::endpoint_lib::bdd_interpreter::BddNode {
14648        condition_index: 22,
14649        high_ref: 100000014,
14650        low_ref: 281,
14651    },
14652    crate::endpoint_lib::bdd_interpreter::BddNode {
14653        condition_index: 35,
14654        high_ref: 282,
14655        low_ref: 100000042,
14656    },
14657    crate::endpoint_lib::bdd_interpreter::BddNode {
14658        condition_index: 36,
14659        high_ref: 100000102,
14660        low_ref: 283,
14661    },
14662    crate::endpoint_lib::bdd_interpreter::BddNode {
14663        condition_index: 46,
14664        high_ref: 100000106,
14665        low_ref: 100000107,
14666    },
14667    crate::endpoint_lib::bdd_interpreter::BddNode {
14668        condition_index: 6,
14669        high_ref: 405,
14670        low_ref: 285,
14671    },
14672    crate::endpoint_lib::bdd_interpreter::BddNode {
14673        condition_index: 7,
14674        high_ref: 395,
14675        low_ref: 286,
14676    },
14677    crate::endpoint_lib::bdd_interpreter::BddNode {
14678        condition_index: 8,
14679        high_ref: 295,
14680        low_ref: 287,
14681    },
14682    crate::endpoint_lib::bdd_interpreter::BddNode {
14683        condition_index: 14,
14684        high_ref: 501,
14685        low_ref: 288,
14686    },
14687    crate::endpoint_lib::bdd_interpreter::BddNode {
14688        condition_index: 26,
14689        high_ref: 289,
14690        low_ref: 502,
14691    },
14692    crate::endpoint_lib::bdd_interpreter::BddNode {
14693        condition_index: 37,
14694        high_ref: 290,
14695        low_ref: 100000086,
14696    },
14697    crate::endpoint_lib::bdd_interpreter::BddNode {
14698        condition_index: 38,
14699        high_ref: 100000086,
14700        low_ref: 291,
14701    },
14702    crate::endpoint_lib::bdd_interpreter::BddNode {
14703        condition_index: 39,
14704        high_ref: 292,
14705        low_ref: 307,
14706    },
14707    crate::endpoint_lib::bdd_interpreter::BddNode {
14708        condition_index: 40,
14709        high_ref: 293,
14710        low_ref: 100000057,
14711    },
14712    crate::endpoint_lib::bdd_interpreter::BddNode {
14713        condition_index: 41,
14714        high_ref: 100000057,
14715        low_ref: 294,
14716    },
14717    crate::endpoint_lib::bdd_interpreter::BddNode {
14718        condition_index: 42,
14719        high_ref: 335,
14720        low_ref: 500,
14721    },
14722    crate::endpoint_lib::bdd_interpreter::BddNode {
14723        condition_index: 9,
14724        high_ref: 296,
14725        low_ref: 300,
14726    },
14727    crate::endpoint_lib::bdd_interpreter::BddNode {
14728        condition_index: 10,
14729        high_ref: 297,
14730        low_ref: 300,
14731    },
14732    crate::endpoint_lib::bdd_interpreter::BddNode {
14733        condition_index: 11,
14734        high_ref: 298,
14735        low_ref: 300,
14736    },
14737    crate::endpoint_lib::bdd_interpreter::BddNode {
14738        condition_index: 12,
14739        high_ref: 299,
14740        low_ref: 300,
14741    },
14742    crate::endpoint_lib::bdd_interpreter::BddNode {
14743        condition_index: 13,
14744        high_ref: 394,
14745        low_ref: 300,
14746    },
14747    crate::endpoint_lib::bdd_interpreter::BddNode {
14748        condition_index: 14,
14749        high_ref: 339,
14750        low_ref: 301,
14751    },
14752    crate::endpoint_lib::bdd_interpreter::BddNode {
14753        condition_index: 15,
14754        high_ref: 100000005,
14755        low_ref: 302,
14756    },
14757    crate::endpoint_lib::bdd_interpreter::BddNode {
14758        condition_index: 20,
14759        high_ref: 337,
14760        low_ref: 303,
14761    },
14762    crate::endpoint_lib::bdd_interpreter::BddNode {
14763        condition_index: 26,
14764        high_ref: 304,
14765        low_ref: 341,
14766    },
14767    crate::endpoint_lib::bdd_interpreter::BddNode {
14768        condition_index: 37,
14769        high_ref: 305,
14770        low_ref: 100000086,
14771    },
14772    crate::endpoint_lib::bdd_interpreter::BddNode {
14773        condition_index: 38,
14774        high_ref: 100000086,
14775        low_ref: 306,
14776    },
14777    crate::endpoint_lib::bdd_interpreter::BddNode {
14778        condition_index: 39,
14779        high_ref: 309,
14780        low_ref: 307,
14781    },
14782    crate::endpoint_lib::bdd_interpreter::BddNode {
14783        condition_index: 48,
14784        high_ref: 100000058,
14785        low_ref: 308,
14786    },
14787    crate::endpoint_lib::bdd_interpreter::BddNode {
14788        condition_index: 50,
14789        high_ref: 100000074,
14790        low_ref: 100000085,
14791    },
14792    crate::endpoint_lib::bdd_interpreter::BddNode {
14793        condition_index: 40,
14794        high_ref: 310,
14795        low_ref: 100000057,
14796    },
14797    crate::endpoint_lib::bdd_interpreter::BddNode {
14798        condition_index: 41,
14799        high_ref: 100000057,
14800        low_ref: 311,
14801    },
14802    crate::endpoint_lib::bdd_interpreter::BddNode {
14803        condition_index: 42,
14804        high_ref: 335,
14805        low_ref: 312,
14806    },
14807    crate::endpoint_lib::bdd_interpreter::BddNode {
14808        condition_index: 48,
14809        high_ref: 324,
14810        low_ref: 313,
14811    },
14812    crate::endpoint_lib::bdd_interpreter::BddNode {
14813        condition_index: 49,
14814        high_ref: 100000045,
14815        low_ref: 314,
14816    },
14817    crate::endpoint_lib::bdd_interpreter::BddNode {
14818        condition_index: 51,
14819        high_ref: 315,
14820        low_ref: 526,
14821    },
14822    crate::endpoint_lib::bdd_interpreter::BddNode {
14823        condition_index: 60,
14824        high_ref: 318,
14825        low_ref: 316,
14826    },
14827    crate::endpoint_lib::bdd_interpreter::BddNode {
14828        condition_index: 62,
14829        high_ref: 100000055,
14830        low_ref: 317,
14831    },
14832    crate::endpoint_lib::bdd_interpreter::BddNode {
14833        condition_index: 63,
14834        high_ref: 319,
14835        low_ref: 100000046,
14836    },
14837    crate::endpoint_lib::bdd_interpreter::BddNode {
14838        condition_index: 62,
14839        high_ref: 100000055,
14840        low_ref: 319,
14841    },
14842    crate::endpoint_lib::bdd_interpreter::BddNode {
14843        condition_index: 64,
14844        high_ref: 320,
14845        low_ref: 100000054,
14846    },
14847    crate::endpoint_lib::bdd_interpreter::BddNode {
14848        condition_index: 66,
14849        high_ref: 321,
14850        low_ref: 100000053,
14851    },
14852    crate::endpoint_lib::bdd_interpreter::BddNode {
14853        condition_index: 69,
14854        high_ref: 322,
14855        low_ref: 100000065,
14856    },
14857    crate::endpoint_lib::bdd_interpreter::BddNode {
14858        condition_index: 70,
14859        high_ref: 323,
14860        low_ref: 100000052,
14861    },
14862    crate::endpoint_lib::bdd_interpreter::BddNode {
14863        condition_index: 72,
14864        high_ref: 100000061,
14865        low_ref: 100000051,
14866    },
14867    crate::endpoint_lib::bdd_interpreter::BddNode {
14868        condition_index: 49,
14869        high_ref: 100000045,
14870        low_ref: 325,
14871    },
14872    crate::endpoint_lib::bdd_interpreter::BddNode {
14873        condition_index: 51,
14874        high_ref: 326,
14875        low_ref: 526,
14876    },
14877    crate::endpoint_lib::bdd_interpreter::BddNode {
14878        condition_index: 60,
14879        high_ref: 329,
14880        low_ref: 327,
14881    },
14882    crate::endpoint_lib::bdd_interpreter::BddNode {
14883        condition_index: 62,
14884        high_ref: 100000055,
14885        low_ref: 328,
14886    },
14887    crate::endpoint_lib::bdd_interpreter::BddNode {
14888        condition_index: 63,
14889        high_ref: 330,
14890        low_ref: 100000046,
14891    },
14892    crate::endpoint_lib::bdd_interpreter::BddNode {
14893        condition_index: 62,
14894        high_ref: 100000055,
14895        low_ref: 330,
14896    },
14897    crate::endpoint_lib::bdd_interpreter::BddNode {
14898        condition_index: 64,
14899        high_ref: 331,
14900        low_ref: 100000054,
14901    },
14902    crate::endpoint_lib::bdd_interpreter::BddNode {
14903        condition_index: 66,
14904        high_ref: 332,
14905        low_ref: 100000053,
14906    },
14907    crate::endpoint_lib::bdd_interpreter::BddNode {
14908        condition_index: 68,
14909        high_ref: 100000047,
14910        low_ref: 333,
14911    },
14912    crate::endpoint_lib::bdd_interpreter::BddNode {
14913        condition_index: 70,
14914        high_ref: 334,
14915        low_ref: 100000052,
14916    },
14917    crate::endpoint_lib::bdd_interpreter::BddNode {
14918        condition_index: 72,
14919        high_ref: 100000049,
14920        low_ref: 100000051,
14921    },
14922    crate::endpoint_lib::bdd_interpreter::BddNode {
14923        condition_index: 48,
14924        high_ref: 100000056,
14925        low_ref: 336,
14926    },
14927    crate::endpoint_lib::bdd_interpreter::BddNode {
14928        condition_index: 52,
14929        high_ref: 100000067,
14930        low_ref: 100000072,
14931    },
14932    crate::endpoint_lib::bdd_interpreter::BddNode {
14933        condition_index: 25,
14934        high_ref: 338,
14935        low_ref: 100000042,
14936    },
14937    crate::endpoint_lib::bdd_interpreter::BddNode {
14938        condition_index: 46,
14939        high_ref: 100000027,
14940        low_ref: 100000028,
14941    },
14942    crate::endpoint_lib::bdd_interpreter::BddNode {
14943        condition_index: 15,
14944        high_ref: 100000005,
14945        low_ref: 340,
14946    },
14947    crate::endpoint_lib::bdd_interpreter::BddNode {
14948        condition_index: 26,
14949        high_ref: 100000088,
14950        low_ref: 341,
14951    },
14952    crate::endpoint_lib::bdd_interpreter::BddNode {
14953        condition_index: 28,
14954        high_ref: 100000087,
14955        low_ref: 342,
14956    },
14957    crate::endpoint_lib::bdd_interpreter::BddNode {
14958        condition_index: 34,
14959        high_ref: 345,
14960        low_ref: 343,
14961    },
14962    crate::endpoint_lib::bdd_interpreter::BddNode {
14963        condition_index: 35,
14964        high_ref: 344,
14965        low_ref: 545,
14966    },
14967    crate::endpoint_lib::bdd_interpreter::BddNode {
14968        condition_index: 36,
14969        high_ref: 100000102,
14970        low_ref: 100000115,
14971    },
14972    crate::endpoint_lib::bdd_interpreter::BddNode {
14973        condition_index: 46,
14974        high_ref: 100000091,
14975        low_ref: 100000092,
14976    },
14977    crate::endpoint_lib::bdd_interpreter::BddNode {
14978        condition_index: 4,
14979        high_ref: 100000002,
14980        low_ref: 347,
14981    },
14982    crate::endpoint_lib::bdd_interpreter::BddNode {
14983        condition_index: 5,
14984        high_ref: 357,
14985        low_ref: 348,
14986    },
14987    crate::endpoint_lib::bdd_interpreter::BddNode {
14988        condition_index: 8,
14989        high_ref: 349,
14990        low_ref: 100000115,
14991    },
14992    crate::endpoint_lib::bdd_interpreter::BddNode {
14993        condition_index: 15,
14994        high_ref: 100000005,
14995        low_ref: 350,
14996    },
14997    crate::endpoint_lib::bdd_interpreter::BddNode {
14998        condition_index: 16,
14999        high_ref: 351,
15000        low_ref: 354,
15001    },
15002    crate::endpoint_lib::bdd_interpreter::BddNode {
15003        condition_index: 18,
15004        high_ref: 352,
15005        low_ref: 354,
15006    },
15007    crate::endpoint_lib::bdd_interpreter::BddNode {
15008        condition_index: 19,
15009        high_ref: 353,
15010        low_ref: 354,
15011    },
15012    crate::endpoint_lib::bdd_interpreter::BddNode {
15013        condition_index: 22,
15014        high_ref: 100000014,
15015        low_ref: 354,
15016    },
15017    crate::endpoint_lib::bdd_interpreter::BddNode {
15018        condition_index: 35,
15019        high_ref: 355,
15020        low_ref: 100000042,
15021    },
15022    crate::endpoint_lib::bdd_interpreter::BddNode {
15023        condition_index: 36,
15024        high_ref: 100000043,
15025        low_ref: 356,
15026    },
15027    crate::endpoint_lib::bdd_interpreter::BddNode {
15028        condition_index: 46,
15029        high_ref: 100000104,
15030        low_ref: 100000105,
15031    },
15032    crate::endpoint_lib::bdd_interpreter::BddNode {
15033        condition_index: 6,
15034        high_ref: 405,
15035        low_ref: 358,
15036    },
15037    crate::endpoint_lib::bdd_interpreter::BddNode {
15038        condition_index: 7,
15039        high_ref: 395,
15040        low_ref: 359,
15041    },
15042    crate::endpoint_lib::bdd_interpreter::BddNode {
15043        condition_index: 8,
15044        high_ref: 360,
15045        low_ref: 491,
15046    },
15047    crate::endpoint_lib::bdd_interpreter::BddNode {
15048        condition_index: 9,
15049        high_ref: 361,
15050        low_ref: 365,
15051    },
15052    crate::endpoint_lib::bdd_interpreter::BddNode {
15053        condition_index: 10,
15054        high_ref: 362,
15055        low_ref: 365,
15056    },
15057    crate::endpoint_lib::bdd_interpreter::BddNode {
15058        condition_index: 11,
15059        high_ref: 363,
15060        low_ref: 365,
15061    },
15062    crate::endpoint_lib::bdd_interpreter::BddNode {
15063        condition_index: 12,
15064        high_ref: 364,
15065        low_ref: 365,
15066    },
15067    crate::endpoint_lib::bdd_interpreter::BddNode {
15068        condition_index: 13,
15069        high_ref: 394,
15070        low_ref: 365,
15071    },
15072    crate::endpoint_lib::bdd_interpreter::BddNode {
15073        condition_index: 14,
15074        high_ref: 389,
15075        low_ref: 366,
15076    },
15077    crate::endpoint_lib::bdd_interpreter::BddNode {
15078        condition_index: 15,
15079        high_ref: 100000005,
15080        low_ref: 367,
15081    },
15082    crate::endpoint_lib::bdd_interpreter::BddNode {
15083        condition_index: 20,
15084        high_ref: 387,
15085        low_ref: 368,
15086    },
15087    crate::endpoint_lib::bdd_interpreter::BddNode {
15088        condition_index: 26,
15089        high_ref: 369,
15090        low_ref: 391,
15091    },
15092    crate::endpoint_lib::bdd_interpreter::BddNode {
15093        condition_index: 37,
15094        high_ref: 370,
15095        low_ref: 100000086,
15096    },
15097    crate::endpoint_lib::bdd_interpreter::BddNode {
15098        condition_index: 38,
15099        high_ref: 100000086,
15100        low_ref: 371,
15101    },
15102    crate::endpoint_lib::bdd_interpreter::BddNode {
15103        condition_index: 39,
15104        high_ref: 372,
15105        low_ref: 518,
15106    },
15107    crate::endpoint_lib::bdd_interpreter::BddNode {
15108        condition_index: 40,
15109        high_ref: 373,
15110        low_ref: 100000057,
15111    },
15112    crate::endpoint_lib::bdd_interpreter::BddNode {
15113        condition_index: 41,
15114        high_ref: 100000057,
15115        low_ref: 374,
15116    },
15117    crate::endpoint_lib::bdd_interpreter::BddNode {
15118        condition_index: 42,
15119        high_ref: 538,
15120        low_ref: 375,
15121    },
15122    crate::endpoint_lib::bdd_interpreter::BddNode {
15123        condition_index: 48,
15124        high_ref: 100000043,
15125        low_ref: 376,
15126    },
15127    crate::endpoint_lib::bdd_interpreter::BddNode {
15128        condition_index: 49,
15129        high_ref: 100000045,
15130        low_ref: 377,
15131    },
15132    crate::endpoint_lib::bdd_interpreter::BddNode {
15133        condition_index: 51,
15134        high_ref: 378,
15135        low_ref: 526,
15136    },
15137    crate::endpoint_lib::bdd_interpreter::BddNode {
15138        condition_index: 60,
15139        high_ref: 381,
15140        low_ref: 379,
15141    },
15142    crate::endpoint_lib::bdd_interpreter::BddNode {
15143        condition_index: 62,
15144        high_ref: 100000055,
15145        low_ref: 380,
15146    },
15147    crate::endpoint_lib::bdd_interpreter::BddNode {
15148        condition_index: 63,
15149        high_ref: 382,
15150        low_ref: 100000046,
15151    },
15152    crate::endpoint_lib::bdd_interpreter::BddNode {
15153        condition_index: 62,
15154        high_ref: 100000055,
15155        low_ref: 382,
15156    },
15157    crate::endpoint_lib::bdd_interpreter::BddNode {
15158        condition_index: 64,
15159        high_ref: 383,
15160        low_ref: 100000054,
15161    },
15162    crate::endpoint_lib::bdd_interpreter::BddNode {
15163        condition_index: 66,
15164        high_ref: 384,
15165        low_ref: 100000053,
15166    },
15167    crate::endpoint_lib::bdd_interpreter::BddNode {
15168        condition_index: 69,
15169        high_ref: 385,
15170        low_ref: 100000065,
15171    },
15172    crate::endpoint_lib::bdd_interpreter::BddNode {
15173        condition_index: 70,
15174        high_ref: 386,
15175        low_ref: 100000052,
15176    },
15177    crate::endpoint_lib::bdd_interpreter::BddNode {
15178        condition_index: 72,
15179        high_ref: 100000060,
15180        low_ref: 100000051,
15181    },
15182    crate::endpoint_lib::bdd_interpreter::BddNode {
15183        condition_index: 25,
15184        high_ref: 388,
15185        low_ref: 100000042,
15186    },
15187    crate::endpoint_lib::bdd_interpreter::BddNode {
15188        condition_index: 46,
15189        high_ref: 100000025,
15190        low_ref: 100000026,
15191    },
15192    crate::endpoint_lib::bdd_interpreter::BddNode {
15193        condition_index: 15,
15194        high_ref: 100000005,
15195        low_ref: 390,
15196    },
15197    crate::endpoint_lib::bdd_interpreter::BddNode {
15198        condition_index: 26,
15199        high_ref: 100000088,
15200        low_ref: 391,
15201    },
15202    crate::endpoint_lib::bdd_interpreter::BddNode {
15203        condition_index: 28,
15204        high_ref: 100000087,
15205        low_ref: 392,
15206    },
15207    crate::endpoint_lib::bdd_interpreter::BddNode {
15208        condition_index: 34,
15209        high_ref: 393,
15210        low_ref: 544,
15211    },
15212    crate::endpoint_lib::bdd_interpreter::BddNode {
15213        condition_index: 46,
15214        high_ref: 100000089,
15215        low_ref: 100000090,
15216    },
15217    crate::endpoint_lib::bdd_interpreter::BddNode {
15218        condition_index: 15,
15219        high_ref: 100000005,
15220        low_ref: 547,
15221    },
15222    crate::endpoint_lib::bdd_interpreter::BddNode {
15223        condition_index: 8,
15224        high_ref: 396,
15225        low_ref: 100000009,
15226    },
15227    crate::endpoint_lib::bdd_interpreter::BddNode {
15228        condition_index: 15,
15229        high_ref: 100000005,
15230        low_ref: 397,
15231    },
15232    crate::endpoint_lib::bdd_interpreter::BddNode {
15233        condition_index: 16,
15234        high_ref: 398,
15235        low_ref: 410,
15236    },
15237    crate::endpoint_lib::bdd_interpreter::BddNode {
15238        condition_index: 18,
15239        high_ref: 399,
15240        low_ref: 410,
15241    },
15242    crate::endpoint_lib::bdd_interpreter::BddNode {
15243        condition_index: 19,
15244        high_ref: 400,
15245        low_ref: 410,
15246    },
15247    crate::endpoint_lib::bdd_interpreter::BddNode {
15248        condition_index: 20,
15249        high_ref: 401,
15250        low_ref: 100000009,
15251    },
15252    crate::endpoint_lib::bdd_interpreter::BddNode {
15253        condition_index: 27,
15254        high_ref: 402,
15255        low_ref: 100000012,
15256    },
15257    crate::endpoint_lib::bdd_interpreter::BddNode {
15258        condition_index: 29,
15259        high_ref: 100000011,
15260        low_ref: 403,
15261    },
15262    crate::endpoint_lib::bdd_interpreter::BddNode {
15263        condition_index: 31,
15264        high_ref: 100000011,
15265        low_ref: 404,
15266    },
15267    crate::endpoint_lib::bdd_interpreter::BddNode {
15268        condition_index: 32,
15269        high_ref: 100000011,
15270        low_ref: 422,
15271    },
15272    crate::endpoint_lib::bdd_interpreter::BddNode {
15273        condition_index: 8,
15274        high_ref: 406,
15275        low_ref: 100000009,
15276    },
15277    crate::endpoint_lib::bdd_interpreter::BddNode {
15278        condition_index: 15,
15279        high_ref: 100000005,
15280        low_ref: 407,
15281    },
15282    crate::endpoint_lib::bdd_interpreter::BddNode {
15283        condition_index: 16,
15284        high_ref: 408,
15285        low_ref: 410,
15286    },
15287    crate::endpoint_lib::bdd_interpreter::BddNode {
15288        condition_index: 18,
15289        high_ref: 409,
15290        low_ref: 410,
15291    },
15292    crate::endpoint_lib::bdd_interpreter::BddNode {
15293        condition_index: 19,
15294        high_ref: 411,
15295        low_ref: 410,
15296    },
15297    crate::endpoint_lib::bdd_interpreter::BddNode {
15298        condition_index: 20,
15299        high_ref: 100000012,
15300        low_ref: 100000009,
15301    },
15302    crate::endpoint_lib::bdd_interpreter::BddNode {
15303        condition_index: 20,
15304        high_ref: 414,
15305        low_ref: 412,
15306    },
15307    crate::endpoint_lib::bdd_interpreter::BddNode {
15308        condition_index: 22,
15309        high_ref: 413,
15310        low_ref: 100000009,
15311    },
15312    crate::endpoint_lib::bdd_interpreter::BddNode {
15313        condition_index: 34,
15314        high_ref: 100000010,
15315        low_ref: 100000009,
15316    },
15317    crate::endpoint_lib::bdd_interpreter::BddNode {
15318        condition_index: 22,
15319        high_ref: 416,
15320        low_ref: 415,
15321    },
15322    crate::endpoint_lib::bdd_interpreter::BddNode {
15323        condition_index: 27,
15324        high_ref: 419,
15325        low_ref: 100000012,
15326    },
15327    crate::endpoint_lib::bdd_interpreter::BddNode {
15328        condition_index: 27,
15329        high_ref: 418,
15330        low_ref: 417,
15331    },
15332    crate::endpoint_lib::bdd_interpreter::BddNode {
15333        condition_index: 34,
15334        high_ref: 100000010,
15335        low_ref: 100000012,
15336    },
15337    crate::endpoint_lib::bdd_interpreter::BddNode {
15338        condition_index: 34,
15339        high_ref: 100000010,
15340        low_ref: 419,
15341    },
15342    crate::endpoint_lib::bdd_interpreter::BddNode {
15343        condition_index: 43,
15344        high_ref: 100000011,
15345        low_ref: 420,
15346    },
15347    crate::endpoint_lib::bdd_interpreter::BddNode {
15348        condition_index: 47,
15349        high_ref: 100000011,
15350        low_ref: 421,
15351    },
15352    crate::endpoint_lib::bdd_interpreter::BddNode {
15353        condition_index: 53,
15354        high_ref: 100000011,
15355        low_ref: 422,
15356    },
15357    crate::endpoint_lib::bdd_interpreter::BddNode {
15358        condition_index: 54,
15359        high_ref: 100000011,
15360        low_ref: 423,
15361    },
15362    crate::endpoint_lib::bdd_interpreter::BddNode {
15363        condition_index: 56,
15364        high_ref: 100000011,
15365        low_ref: 100000012,
15366    },
15367    crate::endpoint_lib::bdd_interpreter::BddNode {
15368        condition_index: 2,
15369        high_ref: 100000001,
15370        low_ref: 425,
15371    },
15372    crate::endpoint_lib::bdd_interpreter::BddNode {
15373        condition_index: 3,
15374        high_ref: 478,
15375        low_ref: 426,
15376    },
15377    crate::endpoint_lib::bdd_interpreter::BddNode {
15378        condition_index: 4,
15379        high_ref: 100000004,
15380        low_ref: 427,
15381    },
15382    crate::endpoint_lib::bdd_interpreter::BddNode {
15383        condition_index: 5,
15384        high_ref: 438,
15385        low_ref: 428,
15386    },
15387    crate::endpoint_lib::bdd_interpreter::BddNode {
15388        condition_index: 8,
15389        high_ref: 429,
15390        low_ref: 100000115,
15391    },
15392    crate::endpoint_lib::bdd_interpreter::BddNode {
15393        condition_index: 16,
15394        high_ref: 430,
15395        low_ref: 433,
15396    },
15397    crate::endpoint_lib::bdd_interpreter::BddNode {
15398        condition_index: 18,
15399        high_ref: 431,
15400        low_ref: 433,
15401    },
15402    crate::endpoint_lib::bdd_interpreter::BddNode {
15403        condition_index: 19,
15404        high_ref: 432,
15405        low_ref: 433,
15406    },
15407    crate::endpoint_lib::bdd_interpreter::BddNode {
15408        condition_index: 22,
15409        high_ref: 100000014,
15410        low_ref: 433,
15411    },
15412    crate::endpoint_lib::bdd_interpreter::BddNode {
15413        condition_index: 35,
15414        high_ref: 434,
15415        low_ref: 100000042,
15416    },
15417    crate::endpoint_lib::bdd_interpreter::BddNode {
15418        condition_index: 36,
15419        high_ref: 100000044,
15420        low_ref: 435,
15421    },
15422    crate::endpoint_lib::bdd_interpreter::BddNode {
15423        condition_index: 46,
15424        high_ref: 100000112,
15425        low_ref: 436,
15426    },
15427    crate::endpoint_lib::bdd_interpreter::BddNode {
15428        condition_index: 57,
15429        high_ref: 437,
15430        low_ref: 100000114,
15431    },
15432    crate::endpoint_lib::bdd_interpreter::BddNode {
15433        condition_index: 58,
15434        high_ref: 100000113,
15435        low_ref: 100000114,
15436    },
15437    crate::endpoint_lib::bdd_interpreter::BddNode {
15438        condition_index: 6,
15439        high_ref: 100000006,
15440        low_ref: 439,
15441    },
15442    crate::endpoint_lib::bdd_interpreter::BddNode {
15443        condition_index: 7,
15444        high_ref: 100000006,
15445        low_ref: 440,
15446    },
15447    crate::endpoint_lib::bdd_interpreter::BddNode {
15448        condition_index: 8,
15449        high_ref: 450,
15450        low_ref: 441,
15451    },
15452    crate::endpoint_lib::bdd_interpreter::BddNode {
15453        condition_index: 14,
15454        high_ref: 501,
15455        low_ref: 442,
15456    },
15457    crate::endpoint_lib::bdd_interpreter::BddNode {
15458        condition_index: 26,
15459        high_ref: 443,
15460        low_ref: 502,
15461    },
15462    crate::endpoint_lib::bdd_interpreter::BddNode {
15463        condition_index: 37,
15464        high_ref: 444,
15465        low_ref: 100000086,
15466    },
15467    crate::endpoint_lib::bdd_interpreter::BddNode {
15468        condition_index: 38,
15469        high_ref: 100000086,
15470        low_ref: 445,
15471    },
15472    crate::endpoint_lib::bdd_interpreter::BddNode {
15473        condition_index: 39,
15474        high_ref: 446,
15475        low_ref: 465,
15476    },
15477    crate::endpoint_lib::bdd_interpreter::BddNode {
15478        condition_index: 40,
15479        high_ref: 447,
15480        low_ref: 100000057,
15481    },
15482    crate::endpoint_lib::bdd_interpreter::BddNode {
15483        condition_index: 41,
15484        high_ref: 100000057,
15485        low_ref: 448,
15486    },
15487    crate::endpoint_lib::bdd_interpreter::BddNode {
15488        condition_index: 42,
15489        high_ref: 471,
15490        low_ref: 449,
15491    },
15492    crate::endpoint_lib::bdd_interpreter::BddNode {
15493        condition_index: 48,
15494        high_ref: 100000044,
15495        low_ref: 500,
15496    },
15497    crate::endpoint_lib::bdd_interpreter::BddNode {
15498        condition_index: 9,
15499        high_ref: 451,
15500        low_ref: 455,
15501    },
15502    crate::endpoint_lib::bdd_interpreter::BddNode {
15503        condition_index: 10,
15504        high_ref: 452,
15505        low_ref: 455,
15506    },
15507    crate::endpoint_lib::bdd_interpreter::BddNode {
15508        condition_index: 11,
15509        high_ref: 453,
15510        low_ref: 455,
15511    },
15512    crate::endpoint_lib::bdd_interpreter::BddNode {
15513        condition_index: 12,
15514        high_ref: 454,
15515        low_ref: 455,
15516    },
15517    crate::endpoint_lib::bdd_interpreter::BddNode {
15518        condition_index: 13,
15519        high_ref: 547,
15520        low_ref: 455,
15521    },
15522    crate::endpoint_lib::bdd_interpreter::BddNode {
15523        condition_index: 14,
15524        high_ref: 473,
15525        low_ref: 456,
15526    },
15527    crate::endpoint_lib::bdd_interpreter::BddNode {
15528        condition_index: 15,
15529        high_ref: 460,
15530        low_ref: 457,
15531    },
15532    crate::endpoint_lib::bdd_interpreter::BddNode {
15533        condition_index: 20,
15534        high_ref: 458,
15535        low_ref: 461,
15536    },
15537    crate::endpoint_lib::bdd_interpreter::BddNode {
15538        condition_index: 25,
15539        high_ref: 459,
15540        low_ref: 100000042,
15541    },
15542    crate::endpoint_lib::bdd_interpreter::BddNode {
15543        condition_index: 46,
15544        high_ref: 100000037,
15545        low_ref: 100000038,
15546    },
15547    crate::endpoint_lib::bdd_interpreter::BddNode {
15548        condition_index: 20,
15549        high_ref: 540,
15550        low_ref: 461,
15551    },
15552    crate::endpoint_lib::bdd_interpreter::BddNode {
15553        condition_index: 26,
15554        high_ref: 462,
15555        low_ref: 474,
15556    },
15557    crate::endpoint_lib::bdd_interpreter::BddNode {
15558        condition_index: 37,
15559        high_ref: 463,
15560        low_ref: 100000086,
15561    },
15562    crate::endpoint_lib::bdd_interpreter::BddNode {
15563        condition_index: 38,
15564        high_ref: 100000086,
15565        low_ref: 464,
15566    },
15567    crate::endpoint_lib::bdd_interpreter::BddNode {
15568        condition_index: 39,
15569        high_ref: 467,
15570        low_ref: 465,
15571    },
15572    crate::endpoint_lib::bdd_interpreter::BddNode {
15573        condition_index: 48,
15574        high_ref: 100000058,
15575        low_ref: 466,
15576    },
15577    crate::endpoint_lib::bdd_interpreter::BddNode {
15578        condition_index: 50,
15579        high_ref: 100000075,
15580        low_ref: 100000085,
15581    },
15582    crate::endpoint_lib::bdd_interpreter::BddNode {
15583        condition_index: 40,
15584        high_ref: 468,
15585        low_ref: 100000057,
15586    },
15587    crate::endpoint_lib::bdd_interpreter::BddNode {
15588        condition_index: 41,
15589        high_ref: 100000057,
15590        low_ref: 469,
15591    },
15592    crate::endpoint_lib::bdd_interpreter::BddNode {
15593        condition_index: 42,
15594        high_ref: 471,
15595        low_ref: 470,
15596    },
15597    crate::endpoint_lib::bdd_interpreter::BddNode {
15598        condition_index: 48,
15599        high_ref: 100000044,
15600        low_ref: 524,
15601    },
15602    crate::endpoint_lib::bdd_interpreter::BddNode {
15603        condition_index: 48,
15604        high_ref: 100000044,
15605        low_ref: 472,
15606    },
15607    crate::endpoint_lib::bdd_interpreter::BddNode {
15608        condition_index: 52,
15609        high_ref: 100000068,
15610        low_ref: 100000072,
15611    },
15612    crate::endpoint_lib::bdd_interpreter::BddNode {
15613        condition_index: 26,
15614        high_ref: 100000088,
15615        low_ref: 474,
15616    },
15617    crate::endpoint_lib::bdd_interpreter::BddNode {
15618        condition_index: 28,
15619        high_ref: 100000087,
15620        low_ref: 475,
15621    },
15622    crate::endpoint_lib::bdd_interpreter::BddNode {
15623        condition_index: 34,
15624        high_ref: 100000100,
15625        low_ref: 476,
15626    },
15627    crate::endpoint_lib::bdd_interpreter::BddNode {
15628        condition_index: 35,
15629        high_ref: 477,
15630        low_ref: 545,
15631    },
15632    crate::endpoint_lib::bdd_interpreter::BddNode {
15633        condition_index: 36,
15634        high_ref: 100000044,
15635        low_ref: 100000115,
15636    },
15637    crate::endpoint_lib::bdd_interpreter::BddNode {
15638        condition_index: 4,
15639        high_ref: 100000002,
15640        low_ref: 479,
15641    },
15642    crate::endpoint_lib::bdd_interpreter::BddNode {
15643        condition_index: 5,
15644        high_ref: 488,
15645        low_ref: 480,
15646    },
15647    crate::endpoint_lib::bdd_interpreter::BddNode {
15648        condition_index: 8,
15649        high_ref: 481,
15650        low_ref: 100000115,
15651    },
15652    crate::endpoint_lib::bdd_interpreter::BddNode {
15653        condition_index: 16,
15654        high_ref: 482,
15655        low_ref: 485,
15656    },
15657    crate::endpoint_lib::bdd_interpreter::BddNode {
15658        condition_index: 18,
15659        high_ref: 483,
15660        low_ref: 485,
15661    },
15662    crate::endpoint_lib::bdd_interpreter::BddNode {
15663        condition_index: 19,
15664        high_ref: 484,
15665        low_ref: 485,
15666    },
15667    crate::endpoint_lib::bdd_interpreter::BddNode {
15668        condition_index: 22,
15669        high_ref: 100000014,
15670        low_ref: 485,
15671    },
15672    crate::endpoint_lib::bdd_interpreter::BddNode {
15673        condition_index: 35,
15674        high_ref: 486,
15675        low_ref: 100000042,
15676    },
15677    crate::endpoint_lib::bdd_interpreter::BddNode {
15678        condition_index: 36,
15679        high_ref: 100000043,
15680        low_ref: 487,
15681    },
15682    crate::endpoint_lib::bdd_interpreter::BddNode {
15683        condition_index: 46,
15684        high_ref: 100000108,
15685        low_ref: 100000109,
15686    },
15687    crate::endpoint_lib::bdd_interpreter::BddNode {
15688        condition_index: 6,
15689        high_ref: 100000006,
15690        low_ref: 489,
15691    },
15692    crate::endpoint_lib::bdd_interpreter::BddNode {
15693        condition_index: 7,
15694        high_ref: 100000006,
15695        low_ref: 490,
15696    },
15697    crate::endpoint_lib::bdd_interpreter::BddNode {
15698        condition_index: 8,
15699        high_ref: 503,
15700        low_ref: 491,
15701    },
15702    crate::endpoint_lib::bdd_interpreter::BddNode {
15703        condition_index: 14,
15704        high_ref: 501,
15705        low_ref: 492,
15706    },
15707    crate::endpoint_lib::bdd_interpreter::BddNode {
15708        condition_index: 26,
15709        high_ref: 493,
15710        low_ref: 502,
15711    },
15712    crate::endpoint_lib::bdd_interpreter::BddNode {
15713        condition_index: 37,
15714        high_ref: 494,
15715        low_ref: 100000086,
15716    },
15717    crate::endpoint_lib::bdd_interpreter::BddNode {
15718        condition_index: 38,
15719        high_ref: 100000086,
15720        low_ref: 495,
15721    },
15722    crate::endpoint_lib::bdd_interpreter::BddNode {
15723        condition_index: 39,
15724        high_ref: 496,
15725        low_ref: 518,
15726    },
15727    crate::endpoint_lib::bdd_interpreter::BddNode {
15728        condition_index: 40,
15729        high_ref: 497,
15730        low_ref: 100000057,
15731    },
15732    crate::endpoint_lib::bdd_interpreter::BddNode {
15733        condition_index: 41,
15734        high_ref: 100000057,
15735        low_ref: 498,
15736    },
15737    crate::endpoint_lib::bdd_interpreter::BddNode {
15738        condition_index: 42,
15739        high_ref: 538,
15740        low_ref: 499,
15741    },
15742    crate::endpoint_lib::bdd_interpreter::BddNode {
15743        condition_index: 48,
15744        high_ref: 100000043,
15745        low_ref: 500,
15746    },
15747    crate::endpoint_lib::bdd_interpreter::BddNode {
15748        condition_index: 49,
15749        high_ref: 100000045,
15750        low_ref: 526,
15751    },
15752    crate::endpoint_lib::bdd_interpreter::BddNode {
15753        condition_index: 26,
15754        high_ref: 100000088,
15755        low_ref: 502,
15756    },
15757    crate::endpoint_lib::bdd_interpreter::BddNode {
15758        condition_index: 28,
15759        high_ref: 100000087,
15760        low_ref: 100000115,
15761    },
15762    crate::endpoint_lib::bdd_interpreter::BddNode {
15763        condition_index: 9,
15764        high_ref: 504,
15765        low_ref: 508,
15766    },
15767    crate::endpoint_lib::bdd_interpreter::BddNode {
15768        condition_index: 10,
15769        high_ref: 505,
15770        low_ref: 508,
15771    },
15772    crate::endpoint_lib::bdd_interpreter::BddNode {
15773        condition_index: 11,
15774        high_ref: 506,
15775        low_ref: 508,
15776    },
15777    crate::endpoint_lib::bdd_interpreter::BddNode {
15778        condition_index: 12,
15779        high_ref: 507,
15780        low_ref: 508,
15781    },
15782    crate::endpoint_lib::bdd_interpreter::BddNode {
15783        condition_index: 13,
15784        high_ref: 547,
15785        low_ref: 508,
15786    },
15787    crate::endpoint_lib::bdd_interpreter::BddNode {
15788        condition_index: 14,
15789        high_ref: 541,
15790        low_ref: 509,
15791    },
15792    crate::endpoint_lib::bdd_interpreter::BddNode {
15793        condition_index: 15,
15794        high_ref: 513,
15795        low_ref: 510,
15796    },
15797    crate::endpoint_lib::bdd_interpreter::BddNode {
15798        condition_index: 20,
15799        high_ref: 511,
15800        low_ref: 514,
15801    },
15802    crate::endpoint_lib::bdd_interpreter::BddNode {
15803        condition_index: 25,
15804        high_ref: 512,
15805        low_ref: 100000042,
15806    },
15807    crate::endpoint_lib::bdd_interpreter::BddNode {
15808        condition_index: 46,
15809        high_ref: 100000029,
15810        low_ref: 100000030,
15811    },
15812    crate::endpoint_lib::bdd_interpreter::BddNode {
15813        condition_index: 20,
15814        high_ref: 540,
15815        low_ref: 514,
15816    },
15817    crate::endpoint_lib::bdd_interpreter::BddNode {
15818        condition_index: 26,
15819        high_ref: 515,
15820        low_ref: 542,
15821    },
15822    crate::endpoint_lib::bdd_interpreter::BddNode {
15823        condition_index: 37,
15824        high_ref: 516,
15825        low_ref: 100000086,
15826    },
15827    crate::endpoint_lib::bdd_interpreter::BddNode {
15828        condition_index: 38,
15829        high_ref: 100000086,
15830        low_ref: 517,
15831    },
15832    crate::endpoint_lib::bdd_interpreter::BddNode {
15833        condition_index: 39,
15834        high_ref: 520,
15835        low_ref: 518,
15836    },
15837    crate::endpoint_lib::bdd_interpreter::BddNode {
15838        condition_index: 48,
15839        high_ref: 100000058,
15840        low_ref: 519,
15841    },
15842    crate::endpoint_lib::bdd_interpreter::BddNode {
15843        condition_index: 50,
15844        high_ref: 100000073,
15845        low_ref: 100000085,
15846    },
15847    crate::endpoint_lib::bdd_interpreter::BddNode {
15848        condition_index: 40,
15849        high_ref: 521,
15850        low_ref: 100000057,
15851    },
15852    crate::endpoint_lib::bdd_interpreter::BddNode {
15853        condition_index: 41,
15854        high_ref: 100000057,
15855        low_ref: 522,
15856    },
15857    crate::endpoint_lib::bdd_interpreter::BddNode {
15858        condition_index: 42,
15859        high_ref: 538,
15860        low_ref: 523,
15861    },
15862    crate::endpoint_lib::bdd_interpreter::BddNode {
15863        condition_index: 48,
15864        high_ref: 100000043,
15865        low_ref: 524,
15866    },
15867    crate::endpoint_lib::bdd_interpreter::BddNode {
15868        condition_index: 49,
15869        high_ref: 100000045,
15870        low_ref: 525,
15871    },
15872    crate::endpoint_lib::bdd_interpreter::BddNode {
15873        condition_index: 51,
15874        high_ref: 529,
15875        low_ref: 526,
15876    },
15877    crate::endpoint_lib::bdd_interpreter::BddNode {
15878        condition_index: 60,
15879        high_ref: 100000055,
15880        low_ref: 527,
15881    },
15882    crate::endpoint_lib::bdd_interpreter::BddNode {
15883        condition_index: 62,
15884        high_ref: 100000055,
15885        low_ref: 528,
15886    },
15887    crate::endpoint_lib::bdd_interpreter::BddNode {
15888        condition_index: 63,
15889        high_ref: 100000055,
15890        low_ref: 100000046,
15891    },
15892    crate::endpoint_lib::bdd_interpreter::BddNode {
15893        condition_index: 60,
15894        high_ref: 532,
15895        low_ref: 530,
15896    },
15897    crate::endpoint_lib::bdd_interpreter::BddNode {
15898        condition_index: 62,
15899        high_ref: 100000055,
15900        low_ref: 531,
15901    },
15902    crate::endpoint_lib::bdd_interpreter::BddNode {
15903        condition_index: 63,
15904        high_ref: 533,
15905        low_ref: 100000046,
15906    },
15907    crate::endpoint_lib::bdd_interpreter::BddNode {
15908        condition_index: 62,
15909        high_ref: 100000055,
15910        low_ref: 533,
15911    },
15912    crate::endpoint_lib::bdd_interpreter::BddNode {
15913        condition_index: 64,
15914        high_ref: 534,
15915        low_ref: 100000054,
15916    },
15917    crate::endpoint_lib::bdd_interpreter::BddNode {
15918        condition_index: 66,
15919        high_ref: 535,
15920        low_ref: 100000053,
15921    },
15922    crate::endpoint_lib::bdd_interpreter::BddNode {
15923        condition_index: 69,
15924        high_ref: 536,
15925        low_ref: 100000065,
15926    },
15927    crate::endpoint_lib::bdd_interpreter::BddNode {
15928        condition_index: 70,
15929        high_ref: 537,
15930        low_ref: 100000052,
15931    },
15932    crate::endpoint_lib::bdd_interpreter::BddNode {
15933        condition_index: 72,
15934        high_ref: 100000059,
15935        low_ref: 100000051,
15936    },
15937    crate::endpoint_lib::bdd_interpreter::BddNode {
15938        condition_index: 48,
15939        high_ref: 100000043,
15940        low_ref: 539,
15941    },
15942    crate::endpoint_lib::bdd_interpreter::BddNode {
15943        condition_index: 52,
15944        high_ref: 100000066,
15945        low_ref: 100000072,
15946    },
15947    crate::endpoint_lib::bdd_interpreter::BddNode {
15948        condition_index: 25,
15949        high_ref: 100000024,
15950        low_ref: 100000042,
15951    },
15952    crate::endpoint_lib::bdd_interpreter::BddNode {
15953        condition_index: 26,
15954        high_ref: 100000088,
15955        low_ref: 542,
15956    },
15957    crate::endpoint_lib::bdd_interpreter::BddNode {
15958        condition_index: 28,
15959        high_ref: 100000087,
15960        low_ref: 543,
15961    },
15962    crate::endpoint_lib::bdd_interpreter::BddNode {
15963        condition_index: 34,
15964        high_ref: 100000100,
15965        low_ref: 544,
15966    },
15967    crate::endpoint_lib::bdd_interpreter::BddNode {
15968        condition_index: 35,
15969        high_ref: 546,
15970        low_ref: 545,
15971    },
15972    crate::endpoint_lib::bdd_interpreter::BddNode {
15973        condition_index: 36,
15974        high_ref: 100000042,
15975        low_ref: 100000115,
15976    },
15977    crate::endpoint_lib::bdd_interpreter::BddNode {
15978        condition_index: 36,
15979        high_ref: 100000043,
15980        low_ref: 100000115,
15981    },
15982    crate::endpoint_lib::bdd_interpreter::BddNode {
15983        condition_index: 17,
15984        high_ref: 548,
15985        low_ref: 100000022,
15986    },
15987    crate::endpoint_lib::bdd_interpreter::BddNode {
15988        condition_index: 20,
15989        high_ref: 549,
15990        low_ref: 100000021,
15991    },
15992    crate::endpoint_lib::bdd_interpreter::BddNode {
15993        condition_index: 33,
15994        high_ref: 552,
15995        low_ref: 550,
15996    },
15997    crate::endpoint_lib::bdd_interpreter::BddNode {
15998        condition_index: 44,
15999        high_ref: 100000017,
16000        low_ref: 551,
16001    },
16002    crate::endpoint_lib::bdd_interpreter::BddNode {
16003        condition_index: 45,
16004        high_ref: 100000019,
16005        low_ref: 100000020,
16006    },
16007    crate::endpoint_lib::bdd_interpreter::BddNode {
16008        condition_index: 44,
16009        high_ref: 100000015,
16010        low_ref: 553,
16011    },
16012    crate::endpoint_lib::bdd_interpreter::BddNode {
16013        condition_index: 45,
16014        high_ref: 100000015,
16015        low_ref: 100000020,
16016    },
16017];
16018// These are all optional since they are set by conditions and will
16019// all be unset when we start evaluation
16020#[derive(Default)]
16021#[allow(unused_lifetimes)]
16022pub(crate) struct ConditionContext<'a> {
16023    pub(crate) partition_result: Option<crate::endpoint_lib::partition::Partition<'a>>,
16024    pub(crate) access_point_suffix: Option<::std::string::String>,
16025    pub(crate) region_prefix: Option<::std::string::String>,
16026    pub(crate) outpost_id_ssa_2: Option<::std::string::String>,
16027    pub(crate) hardware_type: Option<::std::string::String>,
16028    pub(crate) s3_e_ds: Option<::std::string::String>,
16029    pub(crate) s3_e_fips: Option<::std::string::String>,
16030    pub(crate) s3_e_auth: Option<::std::string::String>,
16031    pub(crate) url: Option<crate::endpoint_lib::parse_url::Url<'a>>,
16032    pub(crate) bucket_arn: Option<crate::endpoint_lib::arn::Arn<'a>>,
16033    pub(crate) s3express_availability_zone_id: ::std::option::Option<::std::string::String>,
16034    pub(crate) uri_encoded_bucket: Option<::std::string::String>,
16035    pub(crate) arn_type: ::std::option::Option<::std::string::String>,
16036    pub(crate) access_point_name_ssa_1: ::std::option::Option<::std::string::String>,
16037    pub(crate) bucket_partition: Option<crate::endpoint_lib::partition::Partition<'a>>,
16038    pub(crate) outpost_id_ssa_1: ::std::option::Option<::std::string::String>,
16039    pub(crate) outpost_type: ::std::option::Option<::std::string::String>,
16040    pub(crate) access_point_name_ssa_2: ::std::option::Option<::std::string::String>,
16041    // Sometimes none of the members reference the lifetime, this makes it still valid
16042    phantom: std::marker::PhantomData<&'a ()>,
16043}
16044
16045#[non_exhaustive]
16046#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
16047/// Configuration parameters for resolving the correct endpoint
16048pub struct Params {
16049    /// 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.
16050    pub(crate) bucket: ::std::option::Option<::std::string::String>,
16051    /// The AWS region used to dispatch the request.
16052    pub(crate) region: ::std::option::Option<::std::string::String>,
16053    /// 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.
16054    pub(crate) use_fips: bool,
16055    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
16056    pub(crate) use_dual_stack: bool,
16057    /// Override the endpoint used to send this request
16058    pub(crate) endpoint: ::std::option::Option<::std::string::String>,
16059    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
16060    pub(crate) force_path_style: bool,
16061    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
16062    pub(crate) accelerate: bool,
16063    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
16064    pub(crate) use_global_endpoint: bool,
16065    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
16066    pub(crate) use_object_lambda_endpoint: ::std::option::Option<bool>,
16067    /// 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.
16068    pub(crate) key: ::std::option::Option<::std::string::String>,
16069    /// 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.
16070    pub(crate) prefix: ::std::option::Option<::std::string::String>,
16071    /// 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.
16072    pub(crate) copy_source: ::std::option::Option<::std::string::String>,
16073    /// Internal parameter to disable Access Point Buckets
16074    pub(crate) disable_access_points: ::std::option::Option<bool>,
16075    /// Whether multi-region access points (MRAP) should be disabled.
16076    pub(crate) disable_multi_region_access_points: bool,
16077    /// 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.
16078    pub(crate) use_arn_region: ::std::option::Option<bool>,
16079    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
16080    pub(crate) use_s3_express_control_endpoint: ::std::option::Option<bool>,
16081    /// Parameter to indicate whether S3Express session auth should be disabled
16082    pub(crate) disable_s3_express_session_auth: ::std::option::Option<bool>,
16083}
16084impl Params {
16085    /// Create a builder for [`Params`]
16086    pub fn builder() -> crate::config::endpoint::ParamsBuilder {
16087        crate::config::endpoint::ParamsBuilder::default()
16088    }
16089    /// 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.
16090    pub fn bucket(&self) -> ::std::option::Option<&str> {
16091        self.bucket.as_deref()
16092    }
16093    /// The AWS region used to dispatch the request.
16094    pub fn region(&self) -> ::std::option::Option<&str> {
16095        self.region.as_deref()
16096    }
16097    /// 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.
16098    pub fn use_fips(&self) -> ::std::option::Option<bool> {
16099        Some(self.use_fips)
16100    }
16101    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
16102    pub fn use_dual_stack(&self) -> ::std::option::Option<bool> {
16103        Some(self.use_dual_stack)
16104    }
16105    /// Override the endpoint used to send this request
16106    pub fn endpoint(&self) -> ::std::option::Option<&str> {
16107        self.endpoint.as_deref()
16108    }
16109    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
16110    pub fn force_path_style(&self) -> ::std::option::Option<bool> {
16111        Some(self.force_path_style)
16112    }
16113    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
16114    pub fn accelerate(&self) -> ::std::option::Option<bool> {
16115        Some(self.accelerate)
16116    }
16117    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
16118    pub fn use_global_endpoint(&self) -> ::std::option::Option<bool> {
16119        Some(self.use_global_endpoint)
16120    }
16121    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
16122    pub fn use_object_lambda_endpoint(&self) -> ::std::option::Option<bool> {
16123        self.use_object_lambda_endpoint
16124    }
16125    /// 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.
16126    pub fn key(&self) -> ::std::option::Option<&str> {
16127        self.key.as_deref()
16128    }
16129    /// 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.
16130    pub fn prefix(&self) -> ::std::option::Option<&str> {
16131        self.prefix.as_deref()
16132    }
16133    /// 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.
16134    pub fn copy_source(&self) -> ::std::option::Option<&str> {
16135        self.copy_source.as_deref()
16136    }
16137    /// Internal parameter to disable Access Point Buckets
16138    pub fn disable_access_points(&self) -> ::std::option::Option<bool> {
16139        self.disable_access_points
16140    }
16141    /// Whether multi-region access points (MRAP) should be disabled.
16142    pub fn disable_multi_region_access_points(&self) -> ::std::option::Option<bool> {
16143        Some(self.disable_multi_region_access_points)
16144    }
16145    /// 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.
16146    pub fn use_arn_region(&self) -> ::std::option::Option<bool> {
16147        self.use_arn_region
16148    }
16149    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
16150    pub fn use_s3_express_control_endpoint(&self) -> ::std::option::Option<bool> {
16151        self.use_s3_express_control_endpoint
16152    }
16153    /// Parameter to indicate whether S3Express session auth should be disabled
16154    pub fn disable_s3_express_session_auth(&self) -> ::std::option::Option<bool> {
16155        self.disable_s3_express_session_auth
16156    }
16157}
16158
16159/// Builder for [`Params`]
16160#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
16161pub struct ParamsBuilder {
16162    bucket: ::std::option::Option<::std::string::String>,
16163    region: ::std::option::Option<::std::string::String>,
16164    use_fips: ::std::option::Option<bool>,
16165    use_dual_stack: ::std::option::Option<bool>,
16166    endpoint: ::std::option::Option<::std::string::String>,
16167    force_path_style: ::std::option::Option<bool>,
16168    accelerate: ::std::option::Option<bool>,
16169    use_global_endpoint: ::std::option::Option<bool>,
16170    use_object_lambda_endpoint: ::std::option::Option<bool>,
16171    key: ::std::option::Option<::std::string::String>,
16172    prefix: ::std::option::Option<::std::string::String>,
16173    copy_source: ::std::option::Option<::std::string::String>,
16174    disable_access_points: ::std::option::Option<bool>,
16175    disable_multi_region_access_points: ::std::option::Option<bool>,
16176    use_arn_region: ::std::option::Option<bool>,
16177    use_s3_express_control_endpoint: ::std::option::Option<bool>,
16178    disable_s3_express_session_auth: ::std::option::Option<bool>,
16179}
16180impl ParamsBuilder {
16181    /// Consume this builder, creating [`Params`].
16182    pub fn build(self) -> ::std::result::Result<crate::config::endpoint::Params, crate::config::endpoint::InvalidParams> {
16183        Ok(
16184            #[allow(clippy::unnecessary_lazy_evaluations)]
16185            crate::config::endpoint::Params {
16186                bucket: self.bucket,
16187                region: self.region,
16188                use_fips: self
16189                    .use_fips
16190                    .or_else(|| Some(false))
16191                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_fips"))?,
16192                use_dual_stack: self
16193                    .use_dual_stack
16194                    .or_else(|| Some(false))
16195                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_dual_stack"))?,
16196                endpoint: self.endpoint,
16197                force_path_style: self
16198                    .force_path_style
16199                    .or_else(|| Some(false))
16200                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("force_path_style"))?,
16201                accelerate: self
16202                    .accelerate
16203                    .or_else(|| Some(false))
16204                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("accelerate"))?,
16205                use_global_endpoint: self
16206                    .use_global_endpoint
16207                    .or_else(|| Some(false))
16208                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_global_endpoint"))?,
16209                use_object_lambda_endpoint: self.use_object_lambda_endpoint,
16210                key: self.key,
16211                prefix: self.prefix,
16212                copy_source: self.copy_source,
16213                disable_access_points: self.disable_access_points,
16214                disable_multi_region_access_points: self
16215                    .disable_multi_region_access_points
16216                    .or_else(|| Some(false))
16217                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("disable_multi_region_access_points"))?,
16218                use_arn_region: self.use_arn_region,
16219                use_s3_express_control_endpoint: self.use_s3_express_control_endpoint,
16220                disable_s3_express_session_auth: self.disable_s3_express_session_auth,
16221            },
16222        )
16223    }
16224    /// Sets the value for bucket
16225    ///
16226    /// 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.
16227    pub fn bucket(mut self, value: impl Into<::std::string::String>) -> Self {
16228        self.bucket = Some(value.into());
16229        self
16230    }
16231
16232    /// Sets the value for bucket
16233    ///
16234    /// 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.
16235    pub fn set_bucket(mut self, param: Option<::std::string::String>) -> Self {
16236        self.bucket = param;
16237        self
16238    }
16239    /// Sets the value for region
16240    ///
16241    /// The AWS region used to dispatch the request.
16242    pub fn region(mut self, value: impl Into<::std::string::String>) -> Self {
16243        self.region = Some(value.into());
16244        self
16245    }
16246
16247    /// Sets the value for region
16248    ///
16249    /// The AWS region used to dispatch the request.
16250    pub fn set_region(mut self, param: Option<::std::string::String>) -> Self {
16251        self.region = param;
16252        self
16253    }
16254    /// Sets the value for use_fips
16255    ///
16256    /// When unset, this parameter has a default value of `false`.
16257    /// 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.
16258    pub fn use_fips(mut self, value: impl Into<bool>) -> Self {
16259        self.use_fips = Some(value.into());
16260        self
16261    }
16262
16263    /// Sets the value for use_fips
16264    ///
16265    /// When unset, this parameter has a default value of `false`.
16266    /// 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.
16267    pub fn set_use_fips(mut self, param: Option<bool>) -> Self {
16268        self.use_fips = param;
16269        self
16270    }
16271    /// Sets the value for use_dual_stack
16272    ///
16273    /// When unset, this parameter has a default value of `false`.
16274    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
16275    pub fn use_dual_stack(mut self, value: impl Into<bool>) -> Self {
16276        self.use_dual_stack = Some(value.into());
16277        self
16278    }
16279
16280    /// Sets the value for use_dual_stack
16281    ///
16282    /// When unset, this parameter has a default value of `false`.
16283    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
16284    pub fn set_use_dual_stack(mut self, param: Option<bool>) -> Self {
16285        self.use_dual_stack = param;
16286        self
16287    }
16288    /// Sets the value for endpoint
16289    ///
16290    /// Override the endpoint used to send this request
16291    pub fn endpoint(mut self, value: impl Into<::std::string::String>) -> Self {
16292        self.endpoint = Some(value.into());
16293        self
16294    }
16295
16296    /// Sets the value for endpoint
16297    ///
16298    /// Override the endpoint used to send this request
16299    pub fn set_endpoint(mut self, param: Option<::std::string::String>) -> Self {
16300        self.endpoint = param;
16301        self
16302    }
16303    /// Sets the value for force_path_style
16304    ///
16305    /// When unset, this parameter has a default value of `false`.
16306    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
16307    pub fn force_path_style(mut self, value: impl Into<bool>) -> Self {
16308        self.force_path_style = Some(value.into());
16309        self
16310    }
16311
16312    /// Sets the value for force_path_style
16313    ///
16314    /// When unset, this parameter has a default value of `false`.
16315    /// When true, force a path-style endpoint to be used where the bucket name is part of the path.
16316    pub fn set_force_path_style(mut self, param: Option<bool>) -> Self {
16317        self.force_path_style = param;
16318        self
16319    }
16320    /// Sets the value for accelerate
16321    ///
16322    /// When unset, this parameter has a default value of `false`.
16323    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
16324    pub fn accelerate(mut self, value: impl Into<bool>) -> Self {
16325        self.accelerate = Some(value.into());
16326        self
16327    }
16328
16329    /// Sets the value for accelerate
16330    ///
16331    /// When unset, this parameter has a default value of `false`.
16332    /// When true, use S3 Accelerate. NOTE: Not all regions support S3 accelerate.
16333    pub fn set_accelerate(mut self, param: Option<bool>) -> Self {
16334        self.accelerate = param;
16335        self
16336    }
16337    /// Sets the value for use_global_endpoint
16338    ///
16339    /// When unset, this parameter has a default value of `false`.
16340    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
16341    pub fn use_global_endpoint(mut self, value: impl Into<bool>) -> Self {
16342        self.use_global_endpoint = Some(value.into());
16343        self
16344    }
16345
16346    /// Sets the value for use_global_endpoint
16347    ///
16348    /// When unset, this parameter has a default value of `false`.
16349    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
16350    pub fn set_use_global_endpoint(mut self, param: Option<bool>) -> Self {
16351        self.use_global_endpoint = param;
16352        self
16353    }
16354    /// Sets the value for use_object_lambda_endpoint
16355    ///
16356    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
16357    pub fn use_object_lambda_endpoint(mut self, value: impl Into<bool>) -> Self {
16358        self.use_object_lambda_endpoint = Some(value.into());
16359        self
16360    }
16361
16362    /// Sets the value for use_object_lambda_endpoint
16363    ///
16364    /// Internal parameter to use object lambda endpoint for an operation (eg: WriteGetObjectResponse)
16365    pub fn set_use_object_lambda_endpoint(mut self, param: Option<bool>) -> Self {
16366        self.use_object_lambda_endpoint = param;
16367        self
16368    }
16369    /// Sets the value for key
16370    ///
16371    /// 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.
16372    pub fn key(mut self, value: impl Into<::std::string::String>) -> Self {
16373        self.key = Some(value.into());
16374        self
16375    }
16376
16377    /// Sets the value for key
16378    ///
16379    /// 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.
16380    pub fn set_key(mut self, param: Option<::std::string::String>) -> Self {
16381        self.key = param;
16382        self
16383    }
16384    /// Sets the value for prefix
16385    ///
16386    /// 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.
16387    pub fn prefix(mut self, value: impl Into<::std::string::String>) -> Self {
16388        self.prefix = Some(value.into());
16389        self
16390    }
16391
16392    /// Sets the value for prefix
16393    ///
16394    /// 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.
16395    pub fn set_prefix(mut self, param: Option<::std::string::String>) -> Self {
16396        self.prefix = param;
16397        self
16398    }
16399    /// Sets the value for copy_source
16400    ///
16401    /// 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.
16402    pub fn copy_source(mut self, value: impl Into<::std::string::String>) -> Self {
16403        self.copy_source = Some(value.into());
16404        self
16405    }
16406
16407    /// Sets the value for copy_source
16408    ///
16409    /// 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.
16410    pub fn set_copy_source(mut self, param: Option<::std::string::String>) -> Self {
16411        self.copy_source = param;
16412        self
16413    }
16414    /// Sets the value for disable_access_points
16415    ///
16416    /// Internal parameter to disable Access Point Buckets
16417    pub fn disable_access_points(mut self, value: impl Into<bool>) -> Self {
16418        self.disable_access_points = Some(value.into());
16419        self
16420    }
16421
16422    /// Sets the value for disable_access_points
16423    ///
16424    /// Internal parameter to disable Access Point Buckets
16425    pub fn set_disable_access_points(mut self, param: Option<bool>) -> Self {
16426        self.disable_access_points = param;
16427        self
16428    }
16429    /// Sets the value for disable_multi_region_access_points
16430    ///
16431    /// When unset, this parameter has a default value of `false`.
16432    /// Whether multi-region access points (MRAP) should be disabled.
16433    pub fn disable_multi_region_access_points(mut self, value: impl Into<bool>) -> Self {
16434        self.disable_multi_region_access_points = Some(value.into());
16435        self
16436    }
16437
16438    /// Sets the value for disable_multi_region_access_points
16439    ///
16440    /// When unset, this parameter has a default value of `false`.
16441    /// Whether multi-region access points (MRAP) should be disabled.
16442    pub fn set_disable_multi_region_access_points(mut self, param: Option<bool>) -> Self {
16443        self.disable_multi_region_access_points = param;
16444        self
16445    }
16446    /// Sets the value for use_arn_region
16447    ///
16448    /// 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.
16449    pub fn use_arn_region(mut self, value: impl Into<bool>) -> Self {
16450        self.use_arn_region = Some(value.into());
16451        self
16452    }
16453
16454    /// Sets the value for use_arn_region
16455    ///
16456    /// 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.
16457    pub fn set_use_arn_region(mut self, param: Option<bool>) -> Self {
16458        self.use_arn_region = param;
16459        self
16460    }
16461    /// Sets the value for use_s3_express_control_endpoint
16462    ///
16463    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
16464    pub fn use_s3_express_control_endpoint(mut self, value: impl Into<bool>) -> Self {
16465        self.use_s3_express_control_endpoint = Some(value.into());
16466        self
16467    }
16468
16469    /// Sets the value for use_s3_express_control_endpoint
16470    ///
16471    /// Internal parameter to indicate whether S3Express operation should use control plane, (ex. CreateBucket)
16472    pub fn set_use_s3_express_control_endpoint(mut self, param: Option<bool>) -> Self {
16473        self.use_s3_express_control_endpoint = param;
16474        self
16475    }
16476    /// Sets the value for disable_s3_express_session_auth
16477    ///
16478    /// Parameter to indicate whether S3Express session auth should be disabled
16479    pub fn disable_s3_express_session_auth(mut self, value: impl Into<bool>) -> Self {
16480        self.disable_s3_express_session_auth = Some(value.into());
16481        self
16482    }
16483
16484    /// Sets the value for disable_s3_express_session_auth
16485    ///
16486    /// Parameter to indicate whether S3Express session auth should be disabled
16487    pub fn set_disable_s3_express_session_auth(mut self, param: Option<bool>) -> Self {
16488        self.disable_s3_express_session_auth = param;
16489        self
16490    }
16491}
16492
16493/// An error that occurred during endpoint resolution
16494#[derive(Debug)]
16495pub struct InvalidParams {
16496    field: std::borrow::Cow<'static, str>,
16497    kind: InvalidParamsErrorKind,
16498}
16499
16500/// The kind of invalid parameter error
16501#[derive(Debug)]
16502enum InvalidParamsErrorKind {
16503    MissingField,
16504    InvalidValue { message: &'static str },
16505}
16506
16507impl InvalidParams {
16508    #[allow(dead_code)]
16509    fn missing(field: &'static str) -> Self {
16510        Self {
16511            field: field.into(),
16512            kind: InvalidParamsErrorKind::MissingField,
16513        }
16514    }
16515
16516    #[allow(dead_code)]
16517    fn invalid_value(field: &'static str, message: &'static str) -> Self {
16518        Self {
16519            field: field.into(),
16520            kind: InvalidParamsErrorKind::InvalidValue { message },
16521        }
16522    }
16523}
16524
16525impl std::fmt::Display for InvalidParams {
16526    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16527        match self.kind {
16528            InvalidParamsErrorKind::MissingField => write!(f, "a required field was missing: `{}`", self.field),
16529            InvalidParamsErrorKind::InvalidValue { message } => write!(f, "invalid value for field: `{}` - {}", self.field, message),
16530        }
16531    }
16532}
16533
16534impl std::error::Error for InvalidParams {}
aws_sdk_s3/config/endpoint.rs

aws_sdk_s3/config/
endpoint.rs
