// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#![cfg(feature = "test-util")]
#[::tokio::test]
async fn operation_input_test_get_access_point_1() {
    /* documentation: Vanilla outposts without ARN region + access point ARN@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-west-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-west-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_2() {
    /* documentation: Vanilla outposts without ARN region + access point ARN@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-west-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-west-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_3() {
    /* documentation: Vanilla outposts with ARN region + access point ARN@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_4() {
    /* documentation: Vanilla outposts with ARN region + access point ARN@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_5() {
    /* documentation: accept an access point ARN@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-west-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-west-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_6() {
    /* documentation: accept an access point ARN@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-west-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-west-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_7() {
    /* documentation: vanilla outposts china@cn-north-1 */
    /* builtIns: {
        "AWS::Region": "cn-north-1"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("cn-north-1"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.cn-north-1.amazonaws.com.cn"),
        "expected URI to start with `https://s3-outposts.cn-north-1.amazonaws.com.cn` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_8() {
    /* documentation: vanilla outposts china@cn-north-1 */
    /* builtIns: {
        "AWS::Region": "cn-north-1"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("cn-north-1"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.cn-north-1.amazonaws.com.cn"),
        "expected URI to start with `https://s3-outposts.cn-north-1.amazonaws.com.cn` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_9() {
    /* documentation: gov region@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-west-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-west-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_10() {
    /* documentation: gov region@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-west-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-west-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_11() {
    /* documentation: gov cloud with fips@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-west-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-west-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_12() {
    /* documentation: gov cloud with fips@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-west-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-west-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_13() {
    /* documentation: govcloud with fips + arn region@us-gov-west-1 */
    /* builtIns: {
        "AWS::Region": "us-gov-west-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-gov-west-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-gov-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-gov-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_14() {
    /* documentation: govcloud with fips + arn region@us-gov-west-1 */
    /* builtIns: {
        "AWS::Region": "us-gov-west-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-gov-west-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-gov-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-gov-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_15() {
    /* documentation: gov region@cn-north-1 */
    /* builtIns: {
        "AWS::Region": "cn-north-1"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("cn-north-1"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.cn-north-1.amazonaws.com.cn"),
        "expected URI to start with `https://s3-outposts.cn-north-1.amazonaws.com.cn` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_16() {
    /* documentation: gov region@cn-north-1 */
    /* builtIns: {
        "AWS::Region": "cn-north-1"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("cn-north-1"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.cn-north-1.amazonaws.com.cn"),
        "expected URI to start with `https://s3-outposts.cn-north-1.amazonaws.com.cn` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_17() {
    /* documentation: gov cloud with fips@cn-north-1 */
    /* builtIns: {
        "AWS::Region": "cn-north-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("cn-north-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.cn-north-1.amazonaws.com.cn"),
        "expected URI to start with `https://s3-outposts-fips.cn-north-1.amazonaws.com.cn` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_18() {
    /* documentation: gov cloud with fips@cn-north-1 */
    /* builtIns: {
        "AWS::Region": "cn-north-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("cn-north-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.cn-north-1.amazonaws.com.cn"),
        "expected URI to start with `https://s3-outposts-fips.cn-north-1.amazonaws.com.cn` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_19() {
    /* documentation: govcloud with fips + arn region@us-gov-west-1 */
    /* builtIns: {
        "AWS::Region": "us-gov-west-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-gov-west-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-gov-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-gov-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_20() {
    /* documentation: govcloud with fips + arn region@us-gov-west-1 */
    /* builtIns: {
        "AWS::Region": "us-gov-west-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-gov-west-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-gov-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-gov-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_21() {
    /* documentation: gov region@af-south-1 */
    /* builtIns: {
        "AWS::Region": "af-south-1"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("af-south-1"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.af-south-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.af-south-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_22() {
    /* documentation: gov region@af-south-1 */
    /* builtIns: {
        "AWS::Region": "af-south-1"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("af-south-1"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.af-south-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.af-south-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_23() {
    /* documentation: gov cloud with fips@af-south-1 */
    /* builtIns: {
        "AWS::Region": "af-south-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("af-south-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.af-south-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.af-south-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_24() {
    /* documentation: gov cloud with fips@af-south-1 */
    /* builtIns: {
        "AWS::Region": "af-south-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("af-south-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.af-south-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.af-south-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_25() {
    /* documentation: govcloud with fips + arn region@us-gov-west-1 */
    /* builtIns: {
        "AWS::Region": "us-gov-west-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-gov-west-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-gov-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-gov-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_26() {
    /* documentation: govcloud with fips + arn region@us-gov-west-1 */
    /* builtIns: {
        "AWS::Region": "us-gov-west-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-gov-west-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-gov-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-gov-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_create_bucket_27() {
    /* documentation: CreateBucket + OutpostId = outposts endpoint@us-east-2 */
    /* builtIns: {
        "AWS::Region": "us-east-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .create_bucket()
            .set_bucket(::std::option::Option::Some("blah".to_owned()))
            .set_outpost_id(::std::option::Option::Some("123".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-east-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-east-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_create_bucket_28() {
    /* documentation: CreateBucket + OutpostId with fips = outposts endpoint@us-east-2 */
    /* builtIns: {
        "AWS::Region": "us-east-2",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .create_bucket()
            .set_bucket(::std::option::Option::Some("blah".to_owned()))
            .set_outpost_id(::std::option::Option::Some("123".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-east-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-east-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_create_bucket_29() {
    /* documentation: CreateBucket without OutpostId = regular endpoint@us-east-2 */
    /* builtIns: {
        "AWS::Region": "us-east-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .create_bucket()
            .set_bucket(::std::option::Option::Some("blah".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-control.us-east-2.amazonaws.com"),
        "expected URI to start with `https://s3-control.us-east-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_30() {
    /* documentation: ListRegionalBuckets + OutpostId = outposts endpoint@us-east-2 */
    /* builtIns: {
        "AWS::Region": "us-east-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .set_outpost_id(::std::option::Option::Some("op-123".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-east-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-east-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_31() {
    /* documentation: ListRegionalBuckets without OutpostId = regular endpoint@us-east-2 */
    /* builtIns: {
        "AWS::Region": "us-east-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://123456789012.s3-control.us-east-2.amazonaws.com"),
        "expected URI to start with `https://123456789012.s3-control.us-east-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_32() {
    /* documentation: ListRegionalBucket + OutpostId with fips = outposts endpoint@us-east-2 */
    /* builtIns: {
        "AWS::Region": "us-east-2",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .set_outpost_id(::std::option::Option::Some("op-123".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-east-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-east-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_33() {
    /* documentation: outpost access points support dualstack@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "AWS::UseDualStack": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.use_dual_stack(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-west-2.api.aws"),
        "expected URI to start with `https://s3-outposts.us-west-2.api.aws` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_34() {
    /* documentation: outpost access points support dualstack@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "AWS::UseDualStack": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.use_dual_stack(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-west-2.api.aws"),
        "expected URI to start with `https://s3-outposts.us-west-2.api.aws` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_35() {
    /* documentation: outpost access points support dualstack@af-south-1 */
    /* builtIns: {
        "AWS::Region": "af-south-1",
        "AWS::UseDualStack": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("af-south-1"));
        let builder = builder.use_dual_stack(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.af-south-1.api.aws"),
        "expected URI to start with `https://s3-outposts.af-south-1.api.aws` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_36() {
    /* documentation: outpost access points support dualstack@af-south-1 */
    /* builtIns: {
        "AWS::Region": "af-south-1",
        "AWS::UseDualStack": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("af-south-1"));
        let builder = builder.use_dual_stack(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.af-south-1.api.aws"),
        "expected URI to start with `https://s3-outposts.af-south-1.api.aws` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_37() {
    /* documentation: outpost access points support fips + dualstack@af-south-1 */
    /* builtIns: {
        "AWS::Region": "af-south-1",
        "AWS::UseFIPS": true,
        "AWS::UseDualStack": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("af-south-1"));
        let builder = builder.use_fips(true);
        let builder = builder.use_dual_stack(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.af-south-1.api.aws"),
        "expected URI to start with `https://s3-outposts-fips.af-south-1.api.aws` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_38() {
    /* documentation: outpost access points support fips + dualstack@af-south-1 */
    /* builtIns: {
        "AWS::Region": "af-south-1",
        "AWS::UseFIPS": true,
        "AWS::UseDualStack": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("af-south-1"));
        let builder = builder.use_fips(true);
        let builder = builder.use_dual_stack(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.af-south-1.api.aws"),
        "expected URI to start with `https://s3-outposts-fips.af-south-1.api.aws` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_39() {
    /* documentation: Account ID set inline and in ARN but they both match@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "AWS::S3Control::UseArnRegion": false
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.use_arn_region(false);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-west-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-west-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_40() {
    /* documentation: Account ID set inline and in ARN and they do not match@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "AWS::S3Control::UseArnRegion": false
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.use_arn_region(false);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_account_id(::std::option::Option::Some("999999999999".to_owned()))
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .send()
            .await
    );
    rcvr.expect_no_request();
    let error = _result.expect_err("expected error: Invalid ARN: the accountId specified in the ARN (`123456789012`) does not match the parameter (`999999999999`) [Account ID set inline and in ARN and they do not match@us-west-2]");
    assert!(
                                            format!("{:?}", error).contains("Invalid ARN: the accountId specified in the ARN (`123456789012`) does not match the parameter (`999999999999`)"),
                                            "expected error to contain `Invalid ARN: the accountId specified in the ARN (`123456789012`) does not match the parameter (`999999999999`)` but it was {:?}", error
                                        );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_41() {
    /* documentation: get access point prefixed with account id using endpoint url@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "SDK::Endpoint": "https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.endpoint_url("https://control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com");
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .set_name(::std::option::Option::Some("apname".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://123456789012.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com"),
        "expected URI to start with `https://123456789012.control.vpce-1a2b3c4d-5e6f.s3.us-west-2.vpce.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_42() {
    /* documentation: endpoint url with s3-outposts@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "SDK::Endpoint": "https://beta.example.com"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.endpoint_url("https://beta.example.com");
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://beta.example.com"),
        "expected URI to start with `https://beta.example.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_43() {
    /* documentation: get bucket with endpoint_url@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "SDK::Endpoint": "https://beta.example.com"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.endpoint_url("https://beta.example.com");
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://beta.example.com"),
        "expected URI to start with `https://beta.example.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_44() {
    /* documentation: ListRegionalBucket + OutpostId endpoint url@us-east-2 */
    /* builtIns: {
        "AWS::Region": "us-east-2",
        "SDK::Endpoint": "https://beta.example.com"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        let builder = builder.endpoint_url("https://beta.example.com");
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .set_outpost_id(::std::option::Option::Some("op-123".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://beta.example.com"),
        "expected URI to start with `https://beta.example.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_45() {
    /* documentation: ListRegionalBucket + OutpostId + fips + endpoint url@us-east-2 */
    /* builtIns: {
        "AWS::Region": "us-east-2",
        "AWS::UseFIPS": true,
        "SDK::Endpoint": "https://beta.example.com"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        let builder = builder.use_fips(true);
        let builder = builder.endpoint_url("https://beta.example.com");
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .set_outpost_id(::std::option::Option::Some("op-123".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://beta.example.com"),
        "expected URI to start with `https://beta.example.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_46() {
    /* documentation: ListRegionalBucket + OutpostId + fips + dualstack@us-east-2 */
    /* builtIns: {
        "AWS::Region": "us-east-2",
        "AWS::UseFIPS": true,
        "AWS::UseDualStack": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        let builder = builder.use_fips(true);
        let builder = builder.use_dual_stack(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .set_outpost_id(::std::option::Option::Some("op-123".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-east-2.api.aws"),
        "expected URI to start with `https://s3-outposts-fips.us-east-2.api.aws` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_create_bucket_47() {
    /* documentation: CreateBucket + OutpostId endpoint url@us-east-2 */
    /* builtIns: {
        "AWS::Region": "us-east-2",
        "AWS::UseFIPS": true,
        "SDK::Endpoint": "https://beta.example.com"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        let builder = builder.use_fips(true);
        let builder = builder.endpoint_url("https://beta.example.com");
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .create_bucket()
            .set_bucket(::std::option::Option::Some("blah".to_owned()))
            .set_outpost_id(::std::option::Option::Some("123".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://beta.example.com"),
        "expected URI to start with `https://beta.example.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_create_access_point_48() {
    /* documentation: vanilla bucket arn requires account id@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .create_access_point()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_name(::std::option::Option::Some("apname".to_owned()))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-west-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-west-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_49() {
    /* documentation: bucket arn with UseArnRegion = true (arn region supercedes client configured region)@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_50() {
    /* documentation: bucket ARN in gov partition (non-fips)@us-gov-east-1 */
    /* builtIns: {
        "AWS::Region": "us-gov-east-1"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-gov-east-1"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-gov-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-gov-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_51() {
    /* documentation: bucket ARN in gov partition with FIPS@us-gov-west-1 */
    /* builtIns: {
        "AWS::Region": "us-gov-west-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-gov-west-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws-us-gov:s3-outposts:us-gov-west-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-gov-west-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-gov-west-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_52() {
    /* documentation: bucket ARN in aws partition with FIPS@us-east-2 */
    /* builtIns: {
        "AWS::Region": "us-east-2",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-east-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-east-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_53() {
    /* documentation: bucket ARN in aws partition with fips + dualstack@us-east-2 */
    /* builtIns: {
        "AWS::Region": "us-east-2",
        "AWS::UseFIPS": true,
        "AWS::UseDualStack": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        let builder = builder.use_fips(true);
        let builder = builder.use_dual_stack(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-east-2.api.aws"),
        "expected URI to start with `https://s3-outposts-fips.us-east-2.api.aws` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_create_access_point_54() {
    /* documentation: vanilla bucket arn requires account id@cn-north-1 */
    /* builtIns: {
        "AWS::Region": "cn-north-1"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("cn-north-1"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .create_access_point()
            .set_bucket(::std::option::Option::Some(
                "arn:aws-cn:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_name(::std::option::Option::Some("apname".to_owned()))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.cn-north-1.amazonaws.com.cn"),
        "expected URI to start with `https://s3-outposts.cn-north-1.amazonaws.com.cn` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_55() {
    /* documentation: bucket arn with UseArnRegion = true (arn region supercedes client configured region)@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_56() {
    /* documentation: bucket ARN in gov partition (non-fips)@us-gov-east-1 */
    /* builtIns: {
        "AWS::Region": "us-gov-east-1"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-gov-east-1"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-gov-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-gov-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_57() {
    /* documentation: bucket ARN in gov partition with FIPS@us-gov-west-1 */
    /* builtIns: {
        "AWS::Region": "us-gov-west-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-gov-west-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws-us-gov:s3-outposts:us-gov-west-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-gov-west-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-gov-west-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_58() {
    /* documentation: bucket ARN in aws partition with FIPS@us-east-2 */
    /* builtIns: {
        "AWS::Region": "us-east-2",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-east-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-east-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_59() {
    /* documentation: Outposts support dualstack @us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "AWS::UseDualStack": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.use_dual_stack(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-west-2.api.aws"),
        "expected URI to start with `https://s3-outposts.us-west-2.api.aws` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_create_access_point_60() {
    /* documentation: vanilla bucket arn requires account id@af-south-1 */
    /* builtIns: {
        "AWS::Region": "af-south-1"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("af-south-1"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .create_access_point()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:af-south-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_name(::std::option::Option::Some("apname".to_owned()))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.af-south-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.af-south-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_61() {
    /* documentation: bucket arn with UseArnRegion = true (arn region supercedes client configured region)@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_62() {
    /* documentation: bucket ARN in gov partition (non-fips)@us-gov-east-1 */
    /* builtIns: {
        "AWS::Region": "us-gov-east-1"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-gov-east-1"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws-us-gov:s3-outposts:us-gov-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-gov-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-gov-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_63() {
    /* documentation: bucket ARN in gov partition with FIPS@us-gov-west-1 */
    /* builtIns: {
        "AWS::Region": "us-gov-west-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-gov-west-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws-us-gov:s3-outposts:us-gov-west-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-gov-west-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-gov-west-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_64() {
    /* documentation: bucket ARN in aws partition with FIPS@us-east-2 */
    /* builtIns: {
        "AWS::Region": "us-east-2",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts-fips.us-east-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts-fips.us-east-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_65() {
    /* documentation: custom account id prefix @us-east-1 */
    /* builtIns: {
        "AWS::Region": "us-east-1"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://123456789012.s3-control.us-east-1.amazonaws.com"),
        "expected URI to start with `https://123456789012.s3-control.us-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_66() {
    /* documentation: invalid account id prefix @us-east-1 */
    /* builtIns: {
        "AWS::Region": "us-east-1"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_account_id(::std::option::Option::Some("/?invalid&not-host*label".to_owned()))
            .send()
            .await
    );
    rcvr.expect_no_request();
    let error = _result.expect_err("expected error: AccountId must only contain a-z, A-Z, 0-9 and `-`. [invalid account id prefix @us-east-1]");
    assert!(
        format!("{:?}", error).contains("AccountId must only contain a-z, A-Z, 0-9 and `-`."),
        "expected error to contain `AccountId must only contain a-z, A-Z, 0-9 and `-`.` but it was {:?}",
        error
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_67() {
    /* documentation: custom account id prefix with fips@us-east-1 */
    /* builtIns: {
        "AWS::Region": "us-east-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://123456789012.s3-control-fips.us-east-1.amazonaws.com"),
        "expected URI to start with `https://123456789012.s3-control-fips.us-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_68() {
    /* documentation: custom account id prefix with dualstack,fips@us-east-1 */
    /* builtIns: {
        "AWS::Region": "us-east-1",
        "AWS::UseFIPS": true,
        "AWS::UseDualStack": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
        let builder = builder.use_fips(true);
        let builder = builder.use_dual_stack(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://123456789012.s3-control-fips.dualstack.us-east-1.amazonaws.com"),
        "expected URI to start with `https://123456789012.s3-control-fips.dualstack.us-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_69() {
    /* documentation: custom account id with custom endpoint */
    /* builtIns: {
        "AWS::Region": "us-east-1",
        "SDK::Endpoint": "https://example.com"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
        let builder = builder.endpoint_url("https://example.com");
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://123456789012.example.com"),
        "expected URI to start with `https://123456789012.example.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_70() {
    /* documentation: RequiresAccountId with invalid AccountId and custom endpoint */
    /* builtIns: {
        "AWS::Region": "us-east-1",
        "SDK::Endpoint": "https://beta.example.com"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
        let builder = builder.endpoint_url("https://beta.example.com");
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_account_id(::std::option::Option::Some("/?invalid&not-host*label".to_owned()))
            .send()
            .await
    );
    rcvr.expect_no_request();
    let error = _result.expect_err(
        "expected error: AccountId must only contain a-z, A-Z, 0-9 and `-`. [RequiresAccountId with invalid AccountId and custom endpoint]",
    );
    assert!(
        format!("{:?}", error).contains("AccountId must only contain a-z, A-Z, 0-9 and `-`."),
        "expected error to contain `AccountId must only contain a-z, A-Z, 0-9 and `-`.` but it was {:?}",
        error
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_71() {
    /* documentation: account id with custom endpoint, fips */
    /* builtIns: {
        "AWS::Region": "us-east-1",
        "AWS::UseFIPS": true,
        "SDK::Endpoint": "https://example.com"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
        let builder = builder.use_fips(true);
        let builder = builder.endpoint_url("https://example.com");
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://123456789012.example.com"),
        "expected URI to start with `https://123456789012.example.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_72() {
    /* documentation: ListRegionalBuckets + OutpostId with invalid accountId set. */
    /* builtIns: {
        "AWS::Region": "us-east-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-east-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_outpost_id(::std::option::Option::Some("op-123".to_owned()))
            .set_account_id(::std::option::Option::Some("/?invalid&not-host*label".to_owned()))
            .send()
            .await
    );
    rcvr.expect_no_request();
    let error = _result.expect_err(
        "expected error: AccountId must only contain a-z, A-Z, 0-9 and `-`. [ListRegionalBuckets + OutpostId with invalid accountId set.]",
    );
    assert!(
        format!("{:?}", error).contains("AccountId must only contain a-z, A-Z, 0-9 and `-`."),
        "expected error to contain `AccountId must only contain a-z, A-Z, 0-9 and `-`.` but it was {:?}",
        error
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_73() {
    /* documentation: endpoint url with accesspoint (non-arn) */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "SDK::Endpoint": "https://beta.example.com"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.endpoint_url("https://beta.example.com");
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some("apname".to_owned()))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://123456789012.beta.example.com"),
        "expected URI to start with `https://123456789012.beta.example.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_74() {
    /* documentation: DualStack + Custom endpoint is not supported(non-arn) */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "AWS::UseDualStack": true,
        "SDK::Endpoint": "https://beta.example.com"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.use_dual_stack(true);
        let builder = builder.endpoint_url("https://beta.example.com");
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some("apname".to_owned()))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    rcvr.expect_no_request();
    let error = _result.expect_err("expected error: Invalid Configuration: DualStack and custom endpoint are not supported [DualStack + Custom endpoint is not supported(non-arn)]");
    assert!(
        format!("{:?}", error).contains("Invalid Configuration: DualStack and custom endpoint are not supported"),
        "expected error to contain `Invalid Configuration: DualStack and custom endpoint are not supported` but it was {:?}",
        error
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_75() {
    /* documentation: get bucket with custom endpoint and dualstack is not supported@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "AWS::UseDualStack": true,
        "SDK::Endpoint": "https://s3-outposts.us-west-2.api.aws"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.use_dual_stack(true);
        let builder = builder.endpoint_url("https://s3-outposts.us-west-2.api.aws");
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    rcvr.expect_no_request();
    let error = _result.expect_err("expected error: Invalid Configuration: DualStack and custom endpoint are not supported [get bucket with custom endpoint and dualstack is not supported@us-west-2]");
    assert!(
        format!("{:?}", error).contains("Invalid Configuration: DualStack and custom endpoint are not supported"),
        "expected error to contain `Invalid Configuration: DualStack and custom endpoint are not supported` but it was {:?}",
        error
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_76() {
    /* documentation: ListRegionalBuckets + OutpostId with fips in CN. */
    /* builtIns: {
        "AWS::Region": "cn-north-1",
        "AWS::UseFIPS": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("cn-north-1"));
        let builder = builder.use_fips(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_outpost_id(::std::option::Option::Some("op-123".to_owned()))
            .set_account_id(::std::option::Option::Some("0123456789012".to_owned()))
            .send()
            .await
    );
    rcvr.expect_no_request();
    let error = _result.expect_err("expected error: Partition does not support FIPS [ListRegionalBuckets + OutpostId with fips in CN.]");
    assert!(
        format!("{:?}", error).contains("Partition does not support FIPS"),
        "expected error to contain `Partition does not support FIPS` but it was {:?}",
        error
    );
}

#[::tokio::test]
async fn operation_input_test_list_regional_buckets_77() {
    /* documentation: ListRegionalBuckets + invalid OutpostId. */
    /* builtIns: {
        "AWS::Region": "us-west-1"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-1"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .list_regional_buckets()
            .set_outpost_id(::std::option::Option::Some("?outpost/invalid+".to_owned()))
            .set_account_id(::std::option::Option::Some("0123456789012".to_owned()))
            .send()
            .await
    );
    rcvr.expect_no_request();
    let error = _result.expect_err("expected error: OutpostId must only contain a-z, A-Z, 0-9 and `-`. [ListRegionalBuckets + invalid OutpostId.]");
    assert!(
        format!("{:?}", error).contains("OutpostId must only contain a-z, A-Z, 0-9 and `-`."),
        "expected error to contain `OutpostId must only contain a-z, A-Z, 0-9 and `-`.` but it was {:?}",
        error
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_78() {
    /* documentation: Outpost Accesspoint ARN with arn region and client region mismatch with UseArnRegion=false */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "AWS::S3Control::UseArnRegion": false
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.use_arn_region(false);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    rcvr.expect_no_request();
    let error = _result.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false` [Outpost Accesspoint ARN with arn region and client region mismatch with UseArnRegion=false]");
    assert!(
                                            format!("{:?}", error).contains("Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"),
                                            "expected error to contain `Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`` but it was {:?}", error
                                        );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_79() {
    /* documentation: Outpost Accesspoint ARN with arn region and client region mismatch with UseArnRegion=false */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "AWS::S3Control::UseArnRegion": false
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.use_arn_region(false);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    rcvr.expect_no_request();
    let error = _result.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false` [Outpost Accesspoint ARN with arn region and client region mismatch with UseArnRegion=false]");
    assert!(
                                            format!("{:?}", error).contains("Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"),
                                            "expected error to contain `Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`` but it was {:?}", error
                                        );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_80() {
    /* documentation: Outpost Bucket ARN with arn region and client region mismatch with UseArnRegion=false */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "SDK::Endpoint": "https://beta.example.com",
        "AWS::S3Control::UseArnRegion": false
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.endpoint_url("https://beta.example.com");
        let builder = builder.use_arn_region(false);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    rcvr.expect_no_request();
    let error = _result.expect_err("expected error: Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false` [Outpost Bucket ARN with arn region and client region mismatch with UseArnRegion=false]");
    assert!(
                                            format!("{:?}", error).contains("Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`"),
                                            "expected error to contain `Invalid configuration: region from ARN `us-east-1` does not match client region `us-west-2` and UseArnRegion is `false`` but it was {:?}", error
                                        );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_81() {
    /* documentation: Accesspoint ARN with region mismatch and UseArnRegion unset */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_82() {
    /* documentation: Accesspoint ARN with region mismatch and UseArnRegion unset */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_83() {
    /* documentation: Bucket ARN with region mismatch and UseArnRegion unset */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-east-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-east-1.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-east-1.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_84() {
    /* documentation: Outpost Bucket ARN with partition mismatch with UseArnRegion=true */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "AWS::S3Control::UseArnRegion": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.use_arn_region(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    rcvr.expect_no_request();
    let error = _result.expect_err("expected error: Client was configured for partition `aws` but ARN has `aws-cn` [Outpost Bucket ARN with partition mismatch with UseArnRegion=true]");
    assert!(
        format!("{:?}", error).contains("Client was configured for partition `aws` but ARN has `aws-cn`"),
        "expected error to contain `Client was configured for partition `aws` but ARN has `aws-cn`` but it was {:?}",
        error
    );
}

#[::tokio::test]
async fn operation_input_test_get_access_point_85() {
    /* documentation: Accesspoint ARN with partition mismatch and UseArnRegion=true */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "AWS::S3Control::UseArnRegion": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.use_arn_region(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    rcvr.expect_no_request();
    let error = _result.expect_err("expected error: Client was configured for partition `aws` but ARN has `aws-cn` [Accesspoint ARN with partition mismatch and UseArnRegion=true]");
    assert!(
        format!("{:?}", error).contains("Client was configured for partition `aws` but ARN has `aws-cn`"),
        "expected error to contain `Client was configured for partition `aws` but ARN has `aws-cn`` but it was {:?}",
        error
    );
}

#[::tokio::test]
async fn operation_input_test_delete_access_point_86() {
    /* documentation: Accesspoint ARN with partition mismatch and UseArnRegion=true */
    /* builtIns: {
        "AWS::Region": "us-west-2",
        "AWS::S3Control::UseArnRegion": true
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        let builder = builder.use_arn_region(true);
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .delete_access_point()
            .set_name(::std::option::Option::Some(
                "arn:aws:s3-outposts:cn-north-1:123456789012:outpost:op-01234567890123456:accesspoint:myaccesspoint".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    rcvr.expect_no_request();
    let error = _result.expect_err("expected error: Client was configured for partition `aws` but ARN has `aws-cn` [Accesspoint ARN with partition mismatch and UseArnRegion=true]");
    assert!(
        format!("{:?}", error).contains("Client was configured for partition `aws` but ARN has `aws-cn`"),
        "expected error to contain `Client was configured for partition `aws` but ARN has `aws-cn`` but it was {:?}",
        error
    );
}

#[::tokio::test]
async fn operation_input_test_get_bucket_versioning_87() {
    /* documentation: outpost bucket arn@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .get_bucket_versioning()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-west-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-west-2.amazonaws.com` but it was `{}`",
        uri
    );
}

#[::tokio::test]
async fn operation_input_test_put_bucket_versioning_88() {
    /* documentation: outpost bucket arn@us-west-2 */
    /* builtIns: {
        "AWS::Region": "us-west-2"
    } */
    /* clientParams: {} */
    let (http_client, rcvr) = ::aws_smithy_runtime::client::http::test_util::capture_request(None);
    let conf = {
        #[allow(unused_mut)]
        let mut builder = aws_sdk_s3control::Config::builder().with_test_defaults().http_client(http_client);
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        builder.build()
    };
    let client = aws_sdk_s3control::Client::from_conf(conf);
    let _result = dbg!(
        client
            .put_bucket_versioning()
            .set_bucket(::std::option::Option::Some(
                "arn:aws:s3-outposts:us-west-2:123456789012:outpost:op-01234567890123456:bucket:mybucket".to_owned()
            ))
            .set_account_id(::std::option::Option::Some("123456789012".to_owned()))
            .set_versioning_configuration(::std::option::Option::Some(
                aws_sdk_s3control::types::VersioningConfiguration::builder()
                    .set_status(::std::option::Option::Some(
                        "Enabled"
                            .parse::<aws_sdk_s3control::types::BucketVersioningStatus>()
                            .expect("static value validated to member")
                    ))
                    .build()
            ))
            .send()
            .await
    );
    let req = rcvr.expect_request();
    let uri = req.uri().to_string();
    assert!(
        uri.starts_with("https://s3-outposts.us-west-2.amazonaws.com"),
        "expected URI to start with `https://s3-outposts.us-west-2.amazonaws.com` but it was `{}`",
        uri
    );
}