AWS SDK

AWS SDK

rev. b9ccf3dabc550b0fbe85e785b19c58a2472f505e..0aa2b81c2b8d5d717e9cb17fa65a6648cf2f928e

Files changed:

tmp-codegen-diff/services/dynamodb/generated-src/main/kotlin/aws/sdk/kotlin/services/dynamodb/serde/QueryOperationDeserializer.kt

@@ -38,38 +97,98 @@
   58     58   
            setAseErrorMetadata(it, wrappedCall.response, null)
   59     59   
        }
   60     60   
    }
   61     61   
   62     62   
    val ex = when(errorDetails.code) {
   63     63   
        "InternalServerError" -> InternalServerErrorDeserializer().deserialize(context, wrappedCall, payload)
   64     64   
        "InvalidEndpointException" -> InvalidEndpointExceptionDeserializer().deserialize(context, wrappedCall, payload)
   65     65   
        "ProvisionedThroughputExceededException" -> ProvisionedThroughputExceededExceptionDeserializer().deserialize(context, wrappedCall, payload)
   66     66   
        "RequestLimitExceeded" -> RequestLimitExceededDeserializer().deserialize(context, wrappedCall, payload)
   67     67   
        "ResourceNotFoundException" -> ResourceNotFoundExceptionDeserializer().deserialize(context, wrappedCall, payload)
          68  +
        "ThrottlingException" -> ThrottlingExceptionDeserializer().deserialize(context, wrappedCall, payload)
   68     69   
        else -> DynamoDbException(errorDetails.message)
   69     70   
    }
   70     71   
   71     72   
    setAseErrorMetadata(ex, wrappedResponse, errorDetails)
   72     73   
    throw ex
   73     74   
}
   74     75   
   75     76   
private fun deserializeQueryOperationBody(builder: QueryResponse.Builder, payload: ByteArray) {
   76     77   
    val deserializer = JsonDeserializer(payload)
   77     78   
    val CONSUMEDCAPACITY_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Struct, JsonSerialName("ConsumedCapacity"))

tmp-codegen-diff/services/dynamodb/generated-src/main/kotlin/aws/sdk/kotlin/services/dynamodb/serde/RequestLimitExceededDeserializer.kt

@@ -1,1 +55,68 @@
    1      1   
// Code generated by smithy-kotlin-codegen. DO NOT EDIT!
    2      2   
    3      3   
package aws.sdk.kotlin.services.dynamodb.serde
    4      4   
    5      5   
import aws.sdk.kotlin.services.dynamodb.model.RequestLimitExceeded
           6  +
import aws.sdk.kotlin.services.dynamodb.model.ThrottlingReason
    6      7   
import aws.smithy.kotlin.runtime.http.HttpCall
    7      8   
import aws.smithy.kotlin.runtime.http.operation.HttpDeserializer
    8      9   
import aws.smithy.kotlin.runtime.http.response.HttpResponse
    9     10   
import aws.smithy.kotlin.runtime.operation.ExecutionContext
   10     11   
import aws.smithy.kotlin.runtime.serde.SdkFieldDescriptor
   11     12   
import aws.smithy.kotlin.runtime.serde.SdkObjectDescriptor
   12     13   
import aws.smithy.kotlin.runtime.serde.SerialKind
   13     14   
import aws.smithy.kotlin.runtime.serde.asSdkSerializable
   14     15   
import aws.smithy.kotlin.runtime.serde.deserializeList
   15     16   
import aws.smithy.kotlin.runtime.serde.deserializeMap
   16     17   
import aws.smithy.kotlin.runtime.serde.deserializeStruct
   17     18   
import aws.smithy.kotlin.runtime.serde.field
   18     19   
import aws.smithy.kotlin.runtime.serde.json.JsonDeserializer
   19     20   
import aws.smithy.kotlin.runtime.serde.json.JsonSerialName
   20     21   
import aws.smithy.kotlin.runtime.serde.serializeList
   21     22   
import aws.smithy.kotlin.runtime.serde.serializeMap
   22     23   
import aws.smithy.kotlin.runtime.serde.serializeStruct
          24  +
import kotlin.collections.mutableListOf
   23     25   
   24     26   
   25     27   
internal class RequestLimitExceededDeserializer: HttpDeserializer.NonStreaming<RequestLimitExceeded> {
   26     28   
   27     29   
    override fun deserialize(context: ExecutionContext, call: HttpCall, payload: ByteArray?): RequestLimitExceeded {
   28     30   
        val response = call.response
   29     31   
        val builder = RequestLimitExceeded.Builder()
   30     32   
   31     33   
        if (payload != null) {
   32     34   
            deserializeRequestLimitExceededError(builder, payload)
   33     35   
        }
   34     36   
        builder.correctErrors()
   35     37   
        return builder.build()
   36     38   
    }
   37     39   
}
   38     40   
   39     41   
private fun deserializeRequestLimitExceededError(builder: RequestLimitExceeded.Builder, payload: ByteArray) {
   40     42   
    val deserializer = JsonDeserializer(payload)
          43  +
    val THROTTLINGREASONS_DESCRIPTOR = SdkFieldDescriptor(SerialKind.List, JsonSerialName("ThrottlingReasons"))
   41     44   
    val MESSAGE_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, JsonSerialName("message"))
   42     45   
    val OBJ_DESCRIPTOR = SdkObjectDescriptor.build {
          46  +
        field(THROTTLINGREASONS_DESCRIPTOR)
   43     47   
        field(MESSAGE_DESCRIPTOR)
   44     48   
    }
   45     49   
   46     50   
    deserializer.deserializeStruct(OBJ_DESCRIPTOR) {
   47     51   
        loop@while (true) {
   48     52   
            when (findNextFieldIndex()) {
          53  +
                THROTTLINGREASONS_DESCRIPTOR.index -> builder.throttlingReasons =
          54  +
                    deserializer.deserializeList(THROTTLINGREASONS_DESCRIPTOR) {
          55  +
                        val col0 = mutableListOf<ThrottlingReason>()
          56  +
                        while (hasNextElement()) {
          57  +
                            val el0 = if (nextHasValue()) { deserializeThrottlingReasonDocument(deserializer) } else { deserializeNull(); continue }
          58  +
                            col0.add(el0)
          59  +
                        }
          60  +
                        col0
          61  +
                    }
   49     62   
                MESSAGE_DESCRIPTOR.index -> builder.message = deserializeString()
   50     63   
                null -> break@loop
   51     64   
                else -> skipValue()
   52     65   
            }
   53     66   
        }
   54     67   
    }
   55     68   
}

tmp-codegen-diff/services/dynamodb/generated-src/main/kotlin/aws/sdk/kotlin/services/dynamodb/serde/ScanOperationDeserializer.kt

@@ -38,38 +97,98 @@
   58     58   
            setAseErrorMetadata(it, wrappedCall.response, null)
   59     59   
        }
   60     60   
    }
   61     61   
   62     62   
    val ex = when(errorDetails.code) {
   63     63   
        "InternalServerError" -> InternalServerErrorDeserializer().deserialize(context, wrappedCall, payload)
   64     64   
        "InvalidEndpointException" -> InvalidEndpointExceptionDeserializer().deserialize(context, wrappedCall, payload)
   65     65   
        "ProvisionedThroughputExceededException" -> ProvisionedThroughputExceededExceptionDeserializer().deserialize(context, wrappedCall, payload)
   66     66   
        "RequestLimitExceeded" -> RequestLimitExceededDeserializer().deserialize(context, wrappedCall, payload)
   67     67   
        "ResourceNotFoundException" -> ResourceNotFoundExceptionDeserializer().deserialize(context, wrappedCall, payload)
          68  +
        "ThrottlingException" -> ThrottlingExceptionDeserializer().deserialize(context, wrappedCall, payload)
   68     69   
        else -> DynamoDbException(errorDetails.message)
   69     70   
    }
   70     71   
   71     72   
    setAseErrorMetadata(ex, wrappedResponse, errorDetails)
   72     73   
    throw ex
   73     74   
}
   74     75   
   75     76   
private fun deserializeScanOperationBody(builder: ScanResponse.Builder, payload: ByteArray) {
   76     77   
    val deserializer = JsonDeserializer(payload)
   77     78   
    val CONSUMEDCAPACITY_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Struct, JsonSerialName("ConsumedCapacity"))

tmp-codegen-diff/services/dynamodb/generated-src/main/kotlin/aws/sdk/kotlin/services/dynamodb/serde/TransactGetItemsOperationDeserializer.kt

@@ -37,37 +96,97 @@
   57     57   
            setAseErrorMetadata(it, wrappedCall.response, null)
   58     58   
        }
   59     59   
    }
   60     60   
   61     61   
    val ex = when(errorDetails.code) {
   62     62   
        "InternalServerError" -> InternalServerErrorDeserializer().deserialize(context, wrappedCall, payload)
   63     63   
        "InvalidEndpointException" -> InvalidEndpointExceptionDeserializer().deserialize(context, wrappedCall, payload)
   64     64   
        "ProvisionedThroughputExceededException" -> ProvisionedThroughputExceededExceptionDeserializer().deserialize(context, wrappedCall, payload)
   65     65   
        "RequestLimitExceeded" -> RequestLimitExceededDeserializer().deserialize(context, wrappedCall, payload)
   66     66   
        "ResourceNotFoundException" -> ResourceNotFoundExceptionDeserializer().deserialize(context, wrappedCall, payload)
          67  +
        "ThrottlingException" -> ThrottlingExceptionDeserializer().deserialize(context, wrappedCall, payload)
   67     68   
        "TransactionCanceledException" -> TransactionCanceledExceptionDeserializer().deserialize(context, wrappedCall, payload)
   68     69   
        else -> DynamoDbException(errorDetails.message)
   69     70   
    }
   70     71   
   71     72   
    setAseErrorMetadata(ex, wrappedResponse, errorDetails)
   72     73   
    throw ex
   73     74   
}
   74     75   
   75     76   
private fun deserializeTransactGetItemsOperationBody(builder: TransactGetItemsResponse.Builder, payload: ByteArray) {
   76     77   
    val deserializer = JsonDeserializer(payload)

tmp-codegen-diff/services/dynamodb/generated-src/main/kotlin/aws/sdk/kotlin/services/dynamodb/serde/TransactWriteItemsOperationDeserializer.kt

@@ -39,39 +98,99 @@
   59     59   
        }
   60     60   
    }
   61     61   
   62     62   
    val ex = when(errorDetails.code) {
   63     63   
        "IdempotentParameterMismatchException" -> IdempotentParameterMismatchExceptionDeserializer().deserialize(context, wrappedCall, payload)
   64     64   
        "InternalServerError" -> InternalServerErrorDeserializer().deserialize(context, wrappedCall, payload)
   65     65   
        "InvalidEndpointException" -> InvalidEndpointExceptionDeserializer().deserialize(context, wrappedCall, payload)
   66     66   
        "ProvisionedThroughputExceededException" -> ProvisionedThroughputExceededExceptionDeserializer().deserialize(context, wrappedCall, payload)
   67     67   
        "RequestLimitExceeded" -> RequestLimitExceededDeserializer().deserialize(context, wrappedCall, payload)
   68     68   
        "ResourceNotFoundException" -> ResourceNotFoundExceptionDeserializer().deserialize(context, wrappedCall, payload)
          69  +
        "ThrottlingException" -> ThrottlingExceptionDeserializer().deserialize(context, wrappedCall, payload)
   69     70   
        "TransactionCanceledException" -> TransactionCanceledExceptionDeserializer().deserialize(context, wrappedCall, payload)
   70     71   
        "TransactionInProgressException" -> TransactionInProgressExceptionDeserializer().deserialize(context, wrappedCall, payload)
   71     72   
        else -> DynamoDbException(errorDetails.message)
   72     73   
    }
   73     74   
   74     75   
    setAseErrorMetadata(ex, wrappedResponse, errorDetails)
   75     76   
    throw ex
   76     77   
}
   77     78   
   78     79   
private fun deserializeTransactWriteItemsOperationBody(builder: TransactWriteItemsResponse.Builder, payload: ByteArray) {

tmp-codegen-diff/services/dynamodb/generated-src/main/kotlin/aws/sdk/kotlin/services/dynamodb/serde/UpdateContributorInsightsOperationDeserializer.kt

@@ -1,1 +34,35 @@
    1      1   
// Code generated by smithy-kotlin-codegen. DO NOT EDIT!
    2      2   
    3      3   
package aws.sdk.kotlin.services.dynamodb.serde
    4      4   
           5  +
import aws.sdk.kotlin.services.dynamodb.model.ContributorInsightsMode
    5      6   
import aws.sdk.kotlin.services.dynamodb.model.ContributorInsightsStatus
    6      7   
import aws.sdk.kotlin.services.dynamodb.model.DynamoDbException
    7      8   
import aws.sdk.kotlin.services.dynamodb.model.UpdateContributorInsightsResponse
    8      9   
import aws.smithy.kotlin.runtime.awsprotocol.json.RestJsonErrorDeserializer
    9     10   
import aws.smithy.kotlin.runtime.awsprotocol.setAseErrorMetadata
   10     11   
import aws.smithy.kotlin.runtime.awsprotocol.withPayload
   11     12   
import aws.smithy.kotlin.runtime.http.HttpCall
   12     13   
import aws.smithy.kotlin.runtime.http.isSuccess
   13     14   
import aws.smithy.kotlin.runtime.http.operation.HttpDeserializer
   14     15   
import aws.smithy.kotlin.runtime.operation.ExecutionContext
@@ -41,42 +91,95 @@
   61     62   
        "ResourceNotFoundException" -> ResourceNotFoundExceptionDeserializer().deserialize(context, wrappedCall, payload)
   62     63   
        else -> DynamoDbException(errorDetails.message)
   63     64   
    }
   64     65   
   65     66   
    setAseErrorMetadata(ex, wrappedResponse, errorDetails)
   66     67   
    throw ex
   67     68   
}
   68     69   
   69     70   
private fun deserializeUpdateContributorInsightsOperationBody(builder: UpdateContributorInsightsResponse.Builder, payload: ByteArray) {
   70     71   
    val deserializer = JsonDeserializer(payload)
          72  +
    val CONTRIBUTORINSIGHTSMODE_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Enum, JsonSerialName("ContributorInsightsMode"))
   71     73   
    val CONTRIBUTORINSIGHTSSTATUS_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Enum, JsonSerialName("ContributorInsightsStatus"))
   72     74   
    val INDEXNAME_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, JsonSerialName("IndexName"))
   73     75   
    val TABLENAME_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, JsonSerialName("TableName"))
   74     76   
    val OBJ_DESCRIPTOR = SdkObjectDescriptor.build {
          77  +
        field(CONTRIBUTORINSIGHTSMODE_DESCRIPTOR)
   75     78   
        field(CONTRIBUTORINSIGHTSSTATUS_DESCRIPTOR)
   76     79   
        field(INDEXNAME_DESCRIPTOR)
   77     80   
        field(TABLENAME_DESCRIPTOR)
   78     81   
    }
   79     82   
   80     83   
    deserializer.deserializeStruct(OBJ_DESCRIPTOR) {
   81     84   
        loop@while (true) {
   82     85   
            when (findNextFieldIndex()) {
          86  +
                CONTRIBUTORINSIGHTSMODE_DESCRIPTOR.index -> builder.contributorInsightsMode = deserializeString().let { ContributorInsightsMode.fromValue(it) }
   83     87   
                CONTRIBUTORINSIGHTSSTATUS_DESCRIPTOR.index -> builder.contributorInsightsStatus = deserializeString().let { ContributorInsightsStatus.fromValue(it) }
   84     88   
                INDEXNAME_DESCRIPTOR.index -> builder.indexName = deserializeString()
   85     89   
                TABLENAME_DESCRIPTOR.index -> builder.tableName = deserializeString()
   86     90   
                null -> break@loop
   87     91   
                else -> skipValue()
   88     92   
            }
   89     93   
        }
   90     94   
    }
   91     95   
}

tmp-codegen-diff/services/dynamodb/generated-src/main/kotlin/aws/sdk/kotlin/services/dynamodb/serde/UpdateContributorInsightsOperationSerializer.kt

@@ -1,1 +64,68 @@
    1      1   
// Code generated by smithy-kotlin-codegen. DO NOT EDIT!
    2      2   
    3      3   
package aws.sdk.kotlin.services.dynamodb.serde
    4      4   
    5      5   
import aws.sdk.kotlin.services.dynamodb.model.ContributorInsightsAction
           6  +
import aws.sdk.kotlin.services.dynamodb.model.ContributorInsightsMode
    6      7   
import aws.sdk.kotlin.services.dynamodb.model.UpdateContributorInsightsRequest
    7      8   
import aws.smithy.kotlin.runtime.http.HttpBody
    8      9   
import aws.smithy.kotlin.runtime.http.HttpMethod
    9     10   
import aws.smithy.kotlin.runtime.http.operation.HttpSerializer
   10     11   
import aws.smithy.kotlin.runtime.http.request.HttpRequestBuilder
   11     12   
import aws.smithy.kotlin.runtime.http.request.url
   12     13   
import aws.smithy.kotlin.runtime.operation.ExecutionContext
   13     14   
import aws.smithy.kotlin.runtime.serde.SdkFieldDescriptor
   14     15   
import aws.smithy.kotlin.runtime.serde.SdkObjectDescriptor
   15     16   
import aws.smithy.kotlin.runtime.serde.SerialKind
   16     17   
import aws.smithy.kotlin.runtime.serde.asSdkSerializable
   17     18   
import aws.smithy.kotlin.runtime.serde.deserializeList
   18     19   
import aws.smithy.kotlin.runtime.serde.deserializeMap
   19     20   
import aws.smithy.kotlin.runtime.serde.deserializeStruct
   20     21   
import aws.smithy.kotlin.runtime.serde.field
   21     22   
import aws.smithy.kotlin.runtime.serde.json.JsonDeserializer
   22     23   
import aws.smithy.kotlin.runtime.serde.json.JsonSerialName
   23     24   
import aws.smithy.kotlin.runtime.serde.json.JsonSerializer
   24     25   
import aws.smithy.kotlin.runtime.serde.serializeList
   25     26   
import aws.smithy.kotlin.runtime.serde.serializeMap
   26     27   
import aws.smithy.kotlin.runtime.serde.serializeStruct
   27     28   
   28     29   
   29     30   
internal class UpdateContributorInsightsOperationSerializer: HttpSerializer.NonStreaming<UpdateContributorInsightsRequest> {
   30     31   
    override fun serialize(context: ExecutionContext, input: UpdateContributorInsightsRequest): HttpRequestBuilder {
   31     32   
        val builder = HttpRequestBuilder()
   32     33   
        builder.method = HttpMethod.POST
   33     34   
   34     35   
        builder.url {
   35     36   
            path.encoded = "/"
   36     37   
        }
   37     38   
   38     39   
        val payload = serializeUpdateContributorInsightsOperationBody(context, input)
   39     40   
        builder.body = HttpBody.fromBytes(payload)
   40     41   
        if (builder.body !is HttpBody.Empty) {
   41     42   
            builder.headers.setMissing("Content-Type", "application/x-amz-json-1.0")
   42     43   
        }
   43     44   
        return builder
   44     45   
    }
   45     46   
}
   46     47   
   47     48   
private fun serializeUpdateContributorInsightsOperationBody(context: ExecutionContext, input: UpdateContributorInsightsRequest): ByteArray {
   48     49   
    val serializer = JsonSerializer()
   49     50   
    val CONTRIBUTORINSIGHTSACTION_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Enum, JsonSerialName("ContributorInsightsAction"))
          51  +
    val CONTRIBUTORINSIGHTSMODE_DESCRIPTOR = SdkFieldDescriptor(SerialKind.Enum, JsonSerialName("ContributorInsightsMode"))
   50     52   
    val INDEXNAME_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, JsonSerialName("IndexName"))
   51     53   
    val TABLENAME_DESCRIPTOR = SdkFieldDescriptor(SerialKind.String, JsonSerialName("TableName"))
   52     54   
    val OBJ_DESCRIPTOR = SdkObjectDescriptor.build {
   53     55   
        field(CONTRIBUTORINSIGHTSACTION_DESCRIPTOR)
          56  +
        field(CONTRIBUTORINSIGHTSMODE_DESCRIPTOR)
   54     57   
        field(INDEXNAME_DESCRIPTOR)
   55     58   
        field(TABLENAME_DESCRIPTOR)
   56     59   
    }
   57     60   
   58     61   
    serializer.serializeStruct(OBJ_DESCRIPTOR) {
   59     62   
        input.contributorInsightsAction?.let { field(CONTRIBUTORINSIGHTSACTION_DESCRIPTOR, it.value) }
          63  +
        input.contributorInsightsMode?.let { field(CONTRIBUTORINSIGHTSMODE_DESCRIPTOR, it.value) }
   60     64   
        input.indexName?.let { field(INDEXNAME_DESCRIPTOR, it) }
   61     65   
        input.tableName?.let { field(TABLENAME_DESCRIPTOR, it) }
   62     66   
    }
   63     67   
    return serializer.toByteArray()
   64     68   
}

tmp-codegen-diff/services/dynamodb/generated-src/main/kotlin/aws/sdk/kotlin/services/dynamodb/serde/UpdateItemOperationDeserializer.kt

@@ -41,41 +100,101 @@
   61     61   
   62     62   
    val ex = when(errorDetails.code) {
   63     63   
        "ConditionalCheckFailedException" -> ConditionalCheckFailedExceptionDeserializer().deserialize(context, wrappedCall, payload)
   64     64   
        "InternalServerError" -> InternalServerErrorDeserializer().deserialize(context, wrappedCall, payload)
   65     65   
        "InvalidEndpointException" -> InvalidEndpointExceptionDeserializer().deserialize(context, wrappedCall, payload)
   66     66   
        "ItemCollectionSizeLimitExceededException" -> ItemCollectionSizeLimitExceededExceptionDeserializer().deserialize(context, wrappedCall, payload)
   67     67   
        "ProvisionedThroughputExceededException" -> ProvisionedThroughputExceededExceptionDeserializer().deserialize(context, wrappedCall, payload)
   68     68   
        "ReplicatedWriteConflictException" -> ReplicatedWriteConflictExceptionDeserializer().deserialize(context, wrappedCall, payload)
   69     69   
        "RequestLimitExceeded" -> RequestLimitExceededDeserializer().deserialize(context, wrappedCall, payload)
   70     70   
        "ResourceNotFoundException" -> ResourceNotFoundExceptionDeserializer().deserialize(context, wrappedCall, payload)
          71  +
        "ThrottlingException" -> ThrottlingExceptionDeserializer().deserialize(context, wrappedCall, payload)
   71     72   
        "TransactionConflictException" -> TransactionConflictExceptionDeserializer().deserialize(context, wrappedCall, payload)
   72     73   
        else -> DynamoDbException(errorDetails.message)
   73     74   
    }
   74     75   
   75     76   
    setAseErrorMetadata(ex, wrappedResponse, errorDetails)
   76     77   
    throw ex
   77     78   
}
   78     79   
   79     80   
private fun deserializeUpdateItemOperationBody(builder: UpdateItemResponse.Builder, payload: ByteArray) {
   80     81   
    val deserializer = JsonDeserializer(payload)

tmp-codegen-diff/services/dynamodb/generated-src/test/kotlin/aws/sdk/kotlin/services/dynamodb/endpoints/DefaultEndpointProviderTest.kt

@@ -652,652 +6680,6528 @@
  672    672   
            useFips = false
  673    673   
            useDualStack = false
  674    674   
        }
  675    675   
        val expected = Endpoint(
  676    676   
            uri = Url.parse("https://dynamodb.us-iso-west-1.c2s.ic.gov"),
  677    677   
        )
  678    678   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  679    679   
        expectEqualEndpoints(expected, actual)
  680    680   
    }
  681    681   
  682         -
    // For region us-iso-east-1 with FIPS enabled and DualStack enabled
  683         -
    @Test
  684         -
    fun test43() = runTest {
  685         -
        val params = DynamoDbEndpointParameters {
  686         -
            region = "us-iso-east-1"
  687         -
            useFips = true
  688         -
            useDualStack = true
  689         -
        }
  690         -
        val ex = assertFailsWith<EndpointProviderException> {
  691         -
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  692         -
        }
  693         -
        assertEquals("FIPS and DualStack are enabled, but this partition does not support one or both", ex.message)
  694         -
    }
  695         -
  696    682   
    // For region us-iso-east-1 with FIPS enabled and DualStack disabled
  697    683   
    @Test
  698         -
    fun test44() = runTest {
         684  +
    fun test43() = runTest {
  699    685   
        val params = DynamoDbEndpointParameters {
  700    686   
            region = "us-iso-east-1"
  701    687   
            useFips = true
  702    688   
            useDualStack = false
  703    689   
        }
  704    690   
        val expected = Endpoint(
  705    691   
            uri = Url.parse("https://dynamodb-fips.us-iso-east-1.c2s.ic.gov"),
  706    692   
        )
  707    693   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  708    694   
        expectEqualEndpoints(expected, actual)
  709    695   
    }
  710    696   
  711         -
    // For region us-iso-east-1 with FIPS disabled and DualStack enabled
  712         -
    @Test
  713         -
    fun test45() = runTest {
  714         -
        val params = DynamoDbEndpointParameters {
  715         -
            region = "us-iso-east-1"
  716         -
            useFips = false
  717         -
            useDualStack = true
  718         -
        }
  719         -
        val ex = assertFailsWith<EndpointProviderException> {
  720         -
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  721         -
        }
  722         -
        assertEquals("DualStack is enabled but this partition does not support DualStack", ex.message)
  723         -
    }
  724         -
  725    697   
    // For region us-isob-east-1 with FIPS disabled and DualStack disabled
  726    698   
    @Test
  727         -
    fun test46() = runTest {
         699  +
    fun test44() = runTest {
  728    700   
        val params = DynamoDbEndpointParameters {
  729    701   
            region = "us-isob-east-1"
  730    702   
            useFips = false
  731    703   
            useDualStack = false
  732    704   
        }
  733    705   
        val expected = Endpoint(
  734    706   
            uri = Url.parse("https://dynamodb.us-isob-east-1.sc2s.sgov.gov"),
  735    707   
        )
  736    708   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  737    709   
        expectEqualEndpoints(expected, actual)
  738    710   
    }
  739    711   
  740         -
    // For region us-isob-east-1 with FIPS enabled and DualStack enabled
  741         -
    @Test
  742         -
    fun test47() = runTest {
  743         -
        val params = DynamoDbEndpointParameters {
  744         -
            region = "us-isob-east-1"
  745         -
            useFips = true
  746         -
            useDualStack = true
  747         -
        }
  748         -
        val ex = assertFailsWith<EndpointProviderException> {
  749         -
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  750         -
        }
  751         -
        assertEquals("FIPS and DualStack are enabled, but this partition does not support one or both", ex.message)
  752         -
    }
  753         -
  754    712   
    // For region us-isob-east-1 with FIPS enabled and DualStack disabled
  755    713   
    @Test
  756         -
    fun test48() = runTest {
         714  +
    fun test45() = runTest {
  757    715   
        val params = DynamoDbEndpointParameters {
  758    716   
            region = "us-isob-east-1"
  759    717   
            useFips = true
  760    718   
            useDualStack = false
  761    719   
        }
  762    720   
        val expected = Endpoint(
  763    721   
            uri = Url.parse("https://dynamodb-fips.us-isob-east-1.sc2s.sgov.gov"),
  764    722   
        )
  765    723   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  766    724   
        expectEqualEndpoints(expected, actual)
  767    725   
    }
  768    726   
  769         -
    // For region us-isob-east-1 with FIPS disabled and DualStack enabled
  770         -
    @Test
  771         -
    fun test49() = runTest {
  772         -
        val params = DynamoDbEndpointParameters {
  773         -
            region = "us-isob-east-1"
  774         -
            useFips = false
  775         -
            useDualStack = true
  776         -
        }
  777         -
        val ex = assertFailsWith<EndpointProviderException> {
  778         -
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  779         -
        }
  780         -
        assertEquals("DualStack is enabled but this partition does not support DualStack", ex.message)
  781         -
    }
  782         -
  783    727   
    // For custom endpoint with region set and fips disabled and dualstack disabled
  784    728   
    @Test
  785         -
    fun test50() = runTest {
         729  +
    fun test46() = runTest {
  786    730   
        val params = DynamoDbEndpointParameters {
  787    731   
            region = "us-east-1"
  788    732   
            useFips = false
  789    733   
            useDualStack = false
  790    734   
            endpoint = "https://example.com"
  791    735   
        }
  792    736   
        val expected = Endpoint(
  793    737   
            uri = Url.parse("https://example.com"),
  794    738   
        )
  795    739   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  796    740   
        expectEqualEndpoints(expected, actual)
  797    741   
    }
  798    742   
  799    743   
    // For custom endpoint with region not set and fips disabled and dualstack disabled
  800    744   
    @Test
  801         -
    fun test51() = runTest {
         745  +
    fun test47() = runTest {
  802    746   
        val params = DynamoDbEndpointParameters {
  803    747   
            useFips = false
  804    748   
            useDualStack = false
  805    749   
            endpoint = "https://example.com"
  806    750   
        }
  807    751   
        val expected = Endpoint(
  808    752   
            uri = Url.parse("https://example.com"),
  809    753   
        )
  810    754   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  811    755   
        expectEqualEndpoints(expected, actual)
  812    756   
    }
  813    757   
  814    758   
    // For custom endpoint with fips enabled and dualstack disabled
  815    759   
    @Test
  816         -
    fun test52() = runTest {
         760  +
    fun test48() = runTest {
  817    761   
        val params = DynamoDbEndpointParameters {
  818    762   
            region = "us-east-1"
  819    763   
            useFips = true
  820    764   
            useDualStack = false
  821    765   
            endpoint = "https://example.com"
  822    766   
        }
  823    767   
        val ex = assertFailsWith<EndpointProviderException> {
  824    768   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  825    769   
        }
  826    770   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
  827    771   
    }
  828    772   
  829    773   
    // For custom endpoint with fips disabled and dualstack enabled
  830    774   
    @Test
  831         -
    fun test53() = runTest {
         775  +
    fun test49() = runTest {
  832    776   
        val params = DynamoDbEndpointParameters {
  833    777   
            region = "us-east-1"
  834    778   
            useFips = false
  835    779   
            useDualStack = true
  836    780   
            endpoint = "https://example.com"
  837    781   
        }
  838    782   
        val ex = assertFailsWith<EndpointProviderException> {
  839    783   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  840    784   
        }
  841    785   
        assertEquals("Invalid Configuration: Dualstack and custom endpoint are not supported", ex.message)
  842    786   
    }
  843    787   
  844    788   
    // Missing region
  845    789   
    @Test
  846         -
    fun test54() = runTest {
         790  +
    fun test50() = runTest {
  847    791   
        val params = DynamoDbEndpointParameters {
  848    792   
        }
  849    793   
        val ex = assertFailsWith<EndpointProviderException> {
  850    794   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  851    795   
        }
  852    796   
        assertEquals("Invalid Configuration: Missing Region", ex.message)
  853    797   
    }
  854    798   
  855    799   
    // {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
  856    800   
    @Test
  857         -
    fun test55() = runTest {
         801  +
    fun test51() = runTest {
  858    802   
        val params = DynamoDbEndpointParameters {
  859    803   
            useFips = true
  860    804   
            useDualStack = true
  861    805   
            accountId = "111111111111"
  862    806   
            accountIdEndpointMode = "preferred"
  863    807   
            region = "us-east-1"
  864    808   
            endpoint = "https://example.com"
  865    809   
        }
  866    810   
        val ex = assertFailsWith<EndpointProviderException> {
  867    811   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  868    812   
        }
  869    813   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
  870    814   
    }
  871    815   
  872    816   
    // {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
  873    817   
    @Test
  874         -
    fun test56() = runTest {
         818  +
    fun test52() = runTest {
  875    819   
        val params = DynamoDbEndpointParameters {
  876    820   
            useFips = true
  877    821   
            useDualStack = false
  878    822   
            accountId = "111111111111"
  879    823   
            accountIdEndpointMode = "preferred"
  880    824   
            region = "us-east-1"
  881    825   
            endpoint = "https://example.com"
  882    826   
        }
  883    827   
        val ex = assertFailsWith<EndpointProviderException> {
  884    828   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  885    829   
        }
  886    830   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
  887    831   
    }
  888    832   
  889    833   
    // {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
  890    834   
    @Test
  891         -
    fun test57() = runTest {
         835  +
    fun test53() = runTest {
  892    836   
        val params = DynamoDbEndpointParameters {
  893    837   
            useFips = false
  894    838   
            useDualStack = true
  895    839   
            accountId = "111111111111"
  896    840   
            accountIdEndpointMode = "preferred"
  897    841   
            region = "us-east-1"
  898    842   
            endpoint = "https://example.com"
  899    843   
        }
  900    844   
        val ex = assertFailsWith<EndpointProviderException> {
  901    845   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  902    846   
        }
  903    847   
        assertEquals("Invalid Configuration: Dualstack and custom endpoint are not supported", ex.message)
  904    848   
    }
  905    849   
  906    850   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
  907    851   
    @Test
  908         -
    fun test58() = runTest {
         852  +
    fun test54() = runTest {
  909    853   
        val params = DynamoDbEndpointParameters {
  910    854   
            useFips = false
  911    855   
            useDualStack = false
  912    856   
            accountId = "111111111111"
  913    857   
            accountIdEndpointMode = "preferred"
  914    858   
            region = "us-east-1"
  915    859   
            endpoint = "https://example.com"
  916    860   
        }
  917    861   
        val expected = Endpoint(
  918    862   
            uri = Url.parse("https://example.com"),
  919    863   
        )
  920    864   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  921    865   
        expectEqualEndpoints(expected, actual)
  922    866   
    }
  923    867   
  924    868   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
  925    869   
    @Test
  926         -
    fun test59() = runTest {
         870  +
    fun test55() = runTest {
  927    871   
        val params = DynamoDbEndpointParameters {
  928    872   
            useFips = false
  929    873   
            useDualStack = false
  930    874   
            accountId = "111111111111"
  931    875   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
  932    876   
            accountIdEndpointMode = "preferred"
  933    877   
            region = "us-east-1"
  934    878   
            endpoint = "https://example.com"
  935    879   
        }
  936    880   
        val expected = Endpoint(
  937    881   
            uri = Url.parse("https://example.com"),
  938    882   
        )
  939    883   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  940    884   
        expectEqualEndpoints(expected, actual)
  941    885   
    }
  942    886   
  943    887   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
  944    888   
    @Test
  945         -
    fun test60() = runTest {
         889  +
    fun test56() = runTest {
  946    890   
        val params = DynamoDbEndpointParameters {
  947    891   
            useFips = false
  948    892   
            useDualStack = false
  949    893   
            accountId = "111111111111"
  950    894   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
  951    895   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
  952    896   
            accountIdEndpointMode = "preferred"
  953    897   
            region = "us-east-1"
  954    898   
            endpoint = "https://example.com"
  955    899   
        }
  956    900   
        val expected = Endpoint(
  957    901   
            uri = Url.parse("https://example.com"),
  958    902   
        )
  959    903   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  960    904   
        expectEqualEndpoints(expected, actual)
  961    905   
    }
  962    906   
  963    907   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
  964    908   
    @Test
  965         -
    fun test61() = runTest {
         909  +
    fun test57() = runTest {
  966    910   
        val params = DynamoDbEndpointParameters {
  967    911   
            useFips = false
  968    912   
            useDualStack = false
  969    913   
            accountId = "111111111111"
  970    914   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
  971    915   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
  972    916   
            accountIdEndpointMode = "preferred"
  973    917   
            region = "us-east-1"
  974    918   
            endpoint = "https://example.com"
  975    919   
        }
  976    920   
        val expected = Endpoint(
  977    921   
            uri = Url.parse("https://example.com"),
  978    922   
        )
  979    923   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
  980    924   
        expectEqualEndpoints(expected, actual)
  981    925   
    }
  982    926   
  983    927   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
  984    928   
    @Test
  985         -
    fun test62() = runTest {
         929  +
    fun test58() = runTest {
  986    930   
        val params = DynamoDbEndpointParameters {
  987    931   
            useFips = false
  988    932   
            useDualStack = false
  989    933   
            accountId = "111111111111"
  990    934   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
  991    935   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
  992    936   
            accountIdEndpointMode = "preferred"
  993    937   
            region = "us-east-1"
  994    938   
            endpoint = "https://example.com"
  995    939   
        }
  996    940   
        val expected = Endpoint(
  997    941   
            uri = Url.parse("https://example.com"),
  998    942   
        )
  999    943   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1000    944   
        expectEqualEndpoints(expected, actual)
 1001    945   
    }
 1002    946   
 1003    947   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1004    948   
    @Test
 1005         -
    fun test63() = runTest {
         949  +
    fun test59() = runTest {
 1006    950   
        val params = DynamoDbEndpointParameters {
 1007    951   
            useFips = false
 1008    952   
            useDualStack = false
 1009    953   
            accountId = "111111111111"
 1010    954   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 1011    955   
            resourceArnList = listOf("arn:aws:dynamodb:us-west-2:333333333333:table/table_name")
 1012    956   
            accountIdEndpointMode = "preferred"
 1013    957   
            region = "us-east-1"
 1014    958   
            endpoint = "https://example.com"
 1015    959   
        }
 1016    960   
        val expected = Endpoint(
 1017    961   
            uri = Url.parse("https://example.com"),
 1018    962   
        )
 1019    963   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1020    964   
        expectEqualEndpoints(expected, actual)
 1021    965   
    }
 1022    966   
 1023    967   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1024    968   
    @Test
 1025         -
    fun test64() = runTest {
         969  +
    fun test60() = runTest {
 1026    970   
        val params = DynamoDbEndpointParameters {
 1027    971   
            useFips = false
 1028    972   
            useDualStack = false
 1029    973   
            accountId = "111111111111"
 1030    974   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 1031    975   
            resourceArnList = listOf("arn:aws:s3:us-east-1:333333333333:stream/testStream")
 1032    976   
            accountIdEndpointMode = "preferred"
 1033    977   
            region = "us-east-1"
 1034    978   
            endpoint = "https://example.com"
 1035    979   
        }
 1036    980   
        val expected = Endpoint(
 1037    981   
            uri = Url.parse("https://example.com"),
 1038    982   
        )
 1039    983   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1040    984   
        expectEqualEndpoints(expected, actual)
 1041    985   
    }
 1042    986   
 1043    987   
    // {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1044    988   
    @Test
 1045         -
    fun test65() = runTest {
         989  +
    fun test61() = runTest {
 1046    990   
        val params = DynamoDbEndpointParameters {
 1047    991   
            useFips = false
 1048    992   
            useDualStack = false
 1049    993   
            accountId = ""
 1050    994   
            accountIdEndpointMode = "preferred"
 1051    995   
            region = "us-east-1"
 1052    996   
            endpoint = "https://example.com"
 1053    997   
        }
 1054    998   
        val expected = Endpoint(
 1055    999   
            uri = Url.parse("https://example.com"),
 1056   1000   
        )
 1057   1001   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1058   1002   
        expectEqualEndpoints(expected, actual)
 1059   1003   
    }
 1060   1004   
 1061   1005   
    // {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1062   1006   
    @Test
 1063         -
    fun test66() = runTest {
        1007  +
    fun test62() = runTest {
 1064   1008   
        val params = DynamoDbEndpointParameters {
 1065   1009   
            useFips = true
 1066   1010   
            useDualStack = true
 1067   1011   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1068   1012   
            accountIdEndpointMode = "preferred"
 1069   1013   
            region = "us-east-1"
 1070   1014   
            endpoint = "https://example.com"
 1071   1015   
        }
 1072   1016   
        val ex = assertFailsWith<EndpointProviderException> {
 1073   1017   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1074   1018   
        }
 1075   1019   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 1076   1020   
    }
 1077   1021   
 1078   1022   
    // {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1079   1023   
    @Test
 1080         -
    fun test67() = runTest {
        1024  +
    fun test63() = runTest {
 1081   1025   
        val params = DynamoDbEndpointParameters {
 1082   1026   
            useFips = true
 1083   1027   
            useDualStack = false
 1084   1028   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1085   1029   
            accountIdEndpointMode = "preferred"
 1086   1030   
            region = "us-east-1"
 1087   1031   
            endpoint = "https://example.com"
 1088   1032   
        }
 1089   1033   
        val ex = assertFailsWith<EndpointProviderException> {
 1090   1034   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1091   1035   
        }
 1092   1036   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 1093   1037   
    }
 1094   1038   
 1095   1039   
    // {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1096   1040   
    @Test
 1097         -
    fun test68() = runTest {
        1041  +
    fun test64() = runTest {
 1098   1042   
        val params = DynamoDbEndpointParameters {
 1099   1043   
            useFips = false
 1100   1044   
            useDualStack = true
 1101   1045   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1102   1046   
            accountIdEndpointMode = "preferred"
 1103   1047   
            region = "us-east-1"
 1104   1048   
            endpoint = "https://example.com"
 1105   1049   
        }
 1106   1050   
        val ex = assertFailsWith<EndpointProviderException> {
 1107   1051   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1108   1052   
        }
 1109   1053   
        assertEquals("Invalid Configuration: Dualstack and custom endpoint are not supported", ex.message)
 1110   1054   
    }
 1111   1055   
 1112   1056   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1113   1057   
    @Test
 1114         -
    fun test69() = runTest {
        1058  +
    fun test65() = runTest {
 1115   1059   
        val params = DynamoDbEndpointParameters {
 1116   1060   
            useFips = false
 1117   1061   
            useDualStack = false
 1118   1062   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1119   1063   
            accountIdEndpointMode = "preferred"
 1120   1064   
            region = "us-east-1"
 1121   1065   
            endpoint = "https://example.com"
 1122   1066   
        }
 1123   1067   
        val expected = Endpoint(
 1124   1068   
            uri = Url.parse("https://example.com"),
 1125   1069   
        )
 1126   1070   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1127   1071   
        expectEqualEndpoints(expected, actual)
 1128   1072   
    }
 1129   1073   
 1130   1074   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1131   1075   
    @Test
 1132         -
    fun test70() = runTest {
        1076  +
    fun test66() = runTest {
 1133   1077   
        val params = DynamoDbEndpointParameters {
 1134   1078   
            useFips = false
 1135   1079   
            useDualStack = false
 1136   1080   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 1137   1081   
            accountIdEndpointMode = "preferred"
 1138   1082   
            region = "us-east-1"
 1139   1083   
            endpoint = "https://example.com"
 1140   1084   
        }
 1141   1085   
        val expected = Endpoint(
 1142   1086   
            uri = Url.parse("https://example.com"),
 1143   1087   
        )
 1144   1088   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1145   1089   
        expectEqualEndpoints(expected, actual)
 1146   1090   
    }
 1147   1091   
 1148   1092   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1149   1093   
    @Test
 1150         -
    fun test71() = runTest {
        1094  +
    fun test67() = runTest {
 1151   1095   
        val params = DynamoDbEndpointParameters {
 1152   1096   
            useFips = false
 1153   1097   
            useDualStack = false
 1154   1098   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 1155   1099   
            accountIdEndpointMode = "preferred"
 1156   1100   
            region = "us-east-1"
 1157   1101   
            endpoint = "https://example.com"
 1158   1102   
        }
 1159   1103   
        val expected = Endpoint(
 1160   1104   
            uri = Url.parse("https://example.com"),
 1161   1105   
        )
 1162   1106   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1163   1107   
        expectEqualEndpoints(expected, actual)
 1164   1108   
    }
 1165   1109   
 1166   1110   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1167   1111   
    @Test
 1168         -
    fun test72() = runTest {
        1112  +
    fun test68() = runTest {
 1169   1113   
        val params = DynamoDbEndpointParameters {
 1170   1114   
            useFips = false
 1171   1115   
            useDualStack = false
 1172   1116   
            resourceArn = ""
 1173   1117   
            accountIdEndpointMode = "preferred"
 1174   1118   
            region = "us-east-1"
 1175   1119   
            endpoint = "https://example.com"
 1176   1120   
        }
 1177   1121   
        val expected = Endpoint(
 1178   1122   
            uri = Url.parse("https://example.com"),
 1179   1123   
        )
 1180   1124   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1181   1125   
        expectEqualEndpoints(expected, actual)
 1182   1126   
    }
 1183   1127   
 1184   1128   
    // {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1185   1129   
    @Test
 1186         -
    fun test73() = runTest {
        1130  +
    fun test69() = runTest {
 1187   1131   
        val params = DynamoDbEndpointParameters {
 1188   1132   
            useFips = true
 1189   1133   
            useDualStack = true
 1190   1134   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1191   1135   
            accountIdEndpointMode = "preferred"
 1192   1136   
            region = "us-east-1"
 1193   1137   
            endpoint = "https://example.com"
 1194   1138   
        }
 1195   1139   
        val ex = assertFailsWith<EndpointProviderException> {
 1196   1140   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1197   1141   
        }
 1198   1142   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 1199   1143   
    }
 1200   1144   
 1201   1145   
    // {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1202   1146   
    @Test
 1203         -
    fun test74() = runTest {
        1147  +
    fun test70() = runTest {
 1204   1148   
        val params = DynamoDbEndpointParameters {
 1205   1149   
            useFips = true
 1206   1150   
            useDualStack = false
 1207   1151   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1208   1152   
            accountIdEndpointMode = "preferred"
 1209   1153   
            region = "us-east-1"
 1210   1154   
            endpoint = "https://example.com"
 1211   1155   
        }
 1212   1156   
        val ex = assertFailsWith<EndpointProviderException> {
 1213   1157   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1214   1158   
        }
 1215   1159   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 1216   1160   
    }
 1217   1161   
 1218   1162   
    // {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1219   1163   
    @Test
 1220         -
    fun test75() = runTest {
        1164  +
    fun test71() = runTest {
 1221   1165   
        val params = DynamoDbEndpointParameters {
 1222   1166   
            useFips = false
 1223   1167   
            useDualStack = true
 1224   1168   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1225   1169   
            accountIdEndpointMode = "preferred"
 1226   1170   
            region = "us-east-1"
 1227   1171   
            endpoint = "https://example.com"
 1228   1172   
        }
 1229   1173   
        val ex = assertFailsWith<EndpointProviderException> {
 1230   1174   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1231   1175   
        }
 1232   1176   
        assertEquals("Invalid Configuration: Dualstack and custom endpoint are not supported", ex.message)
 1233   1177   
    }
 1234   1178   
 1235   1179   
    // {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1236   1180   
    @Test
 1237         -
    fun test76() = runTest {
        1181  +
    fun test72() = runTest {
 1238   1182   
        val params = DynamoDbEndpointParameters {
 1239   1183   
            useFips = false
 1240   1184   
            useDualStack = false
 1241   1185   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1242   1186   
            accountIdEndpointMode = "preferred"
 1243   1187   
            region = "us-east-1"
 1244   1188   
            endpoint = "https://example.com"
 1245   1189   
        }
 1246   1190   
        val expected = Endpoint(
 1247   1191   
            uri = Url.parse("https://example.com"),
 1248   1192   
        )
 1249   1193   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1250   1194   
        expectEqualEndpoints(expected, actual)
 1251   1195   
    }
 1252   1196   
 1253   1197   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1254   1198   
    @Test
 1255         -
    fun test77() = runTest {
        1199  +
    fun test73() = runTest {
 1256   1200   
        val params = DynamoDbEndpointParameters {
 1257   1201   
            useFips = false
 1258   1202   
            useDualStack = false
 1259   1203   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1260   1204   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1261   1205   
            accountIdEndpointMode = "preferred"
 1262   1206   
            region = "us-east-1"
 1263   1207   
            endpoint = "https://example.com"
 1264   1208   
        }
 1265   1209   
        val expected = Endpoint(
 1266   1210   
            uri = Url.parse("https://example.com"),
 1267   1211   
        )
 1268   1212   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1269   1213   
        expectEqualEndpoints(expected, actual)
 1270   1214   
    }
 1271   1215   
 1272   1216   
    // {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=preferred, Region=us-east-1, Endpoint=https://example.com}
 1273   1217   
    @Test
 1274         -
    fun test78() = runTest {
        1218  +
    fun test74() = runTest {
 1275   1219   
        val params = DynamoDbEndpointParameters {
 1276   1220   
            useFips = false
 1277   1221   
            useDualStack = false
 1278   1222   
            accountIdEndpointMode = "preferred"
 1279   1223   
            region = "us-east-1"
 1280   1224   
            endpoint = "https://example.com"
 1281   1225   
        }
 1282   1226   
        val expected = Endpoint(
 1283   1227   
            uri = Url.parse("https://example.com"),
 1284   1228   
        )
 1285   1229   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1286   1230   
        expectEqualEndpoints(expected, actual)
 1287   1231   
    }
 1288   1232   
 1289   1233   
    // {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1290   1234   
    @Test
 1291         -
    fun test79() = runTest {
        1235  +
    fun test75() = runTest {
 1292   1236   
        val params = DynamoDbEndpointParameters {
 1293   1237   
            useFips = true
 1294   1238   
            useDualStack = true
 1295   1239   
            accountId = "111111111111"
 1296   1240   
            accountIdEndpointMode = "disabled"
 1297   1241   
            region = "us-east-1"
 1298   1242   
            endpoint = "https://example.com"
 1299   1243   
        }
 1300   1244   
        val ex = assertFailsWith<EndpointProviderException> {
 1301   1245   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1302   1246   
        }
 1303   1247   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 1304   1248   
    }
 1305   1249   
 1306   1250   
    // {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1307   1251   
    @Test
 1308         -
    fun test80() = runTest {
        1252  +
    fun test76() = runTest {
 1309   1253   
        val params = DynamoDbEndpointParameters {
 1310   1254   
            useFips = true
 1311   1255   
            useDualStack = false
 1312   1256   
            accountId = "111111111111"
 1313   1257   
            accountIdEndpointMode = "disabled"
 1314   1258   
            region = "us-east-1"
 1315   1259   
            endpoint = "https://example.com"
 1316   1260   
        }
 1317   1261   
        val ex = assertFailsWith<EndpointProviderException> {
 1318   1262   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1319   1263   
        }
 1320   1264   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 1321   1265   
    }
 1322   1266   
 1323   1267   
    // {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1324   1268   
    @Test
 1325         -
    fun test81() = runTest {
        1269  +
    fun test77() = runTest {
 1326   1270   
        val params = DynamoDbEndpointParameters {
 1327   1271   
            useFips = false
 1328   1272   
            useDualStack = true
 1329   1273   
            accountId = "111111111111"
 1330   1274   
            accountIdEndpointMode = "disabled"
 1331   1275   
            region = "us-east-1"
 1332   1276   
            endpoint = "https://example.com"
 1333   1277   
        }
 1334   1278   
        val ex = assertFailsWith<EndpointProviderException> {
 1335   1279   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1336   1280   
        }
 1337   1281   
        assertEquals("Invalid Configuration: Dualstack and custom endpoint are not supported", ex.message)
 1338   1282   
    }
 1339   1283   
 1340   1284   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1341   1285   
    @Test
 1342         -
    fun test82() = runTest {
        1286  +
    fun test78() = runTest {
 1343   1287   
        val params = DynamoDbEndpointParameters {
 1344   1288   
            useFips = false
 1345   1289   
            useDualStack = false
 1346   1290   
            accountId = "111111111111"
 1347   1291   
            accountIdEndpointMode = "disabled"
 1348   1292   
            region = "us-east-1"
 1349   1293   
            endpoint = "https://example.com"
 1350   1294   
        }
 1351   1295   
        val expected = Endpoint(
 1352   1296   
            uri = Url.parse("https://example.com"),
 1353   1297   
        )
 1354   1298   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1355   1299   
        expectEqualEndpoints(expected, actual)
 1356   1300   
    }
 1357   1301   
 1358   1302   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1359   1303   
    @Test
 1360         -
    fun test83() = runTest {
        1304  +
    fun test79() = runTest {
 1361   1305   
        val params = DynamoDbEndpointParameters {
 1362   1306   
            useFips = false
 1363   1307   
            useDualStack = false
 1364   1308   
            accountId = "111111111111"
 1365   1309   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1366   1310   
            accountIdEndpointMode = "disabled"
 1367   1311   
            region = "us-east-1"
 1368   1312   
            endpoint = "https://example.com"
 1369   1313   
        }
 1370   1314   
        val expected = Endpoint(
 1371   1315   
            uri = Url.parse("https://example.com"),
 1372   1316   
        )
 1373   1317   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1374   1318   
        expectEqualEndpoints(expected, actual)
 1375   1319   
    }
 1376   1320   
 1377   1321   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1378   1322   
    @Test
 1379         -
    fun test84() = runTest {
        1323  +
    fun test80() = runTest {
 1380   1324   
        val params = DynamoDbEndpointParameters {
 1381   1325   
            useFips = false
 1382   1326   
            useDualStack = false
 1383   1327   
            accountId = "111111111111"
 1384   1328   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1385   1329   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1386   1330   
            accountIdEndpointMode = "disabled"
 1387   1331   
            region = "us-east-1"
 1388   1332   
            endpoint = "https://example.com"
 1389   1333   
        }
 1390   1334   
        val expected = Endpoint(
 1391   1335   
            uri = Url.parse("https://example.com"),
 1392   1336   
        )
 1393   1337   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1394   1338   
        expectEqualEndpoints(expected, actual)
 1395   1339   
    }
 1396   1340   
 1397   1341   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1398   1342   
    @Test
 1399         -
    fun test85() = runTest {
        1343  +
    fun test81() = runTest {
 1400   1344   
        val params = DynamoDbEndpointParameters {
 1401   1345   
            useFips = false
 1402   1346   
            useDualStack = false
 1403   1347   
            accountId = "111111111111"
 1404   1348   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 1405   1349   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1406   1350   
            accountIdEndpointMode = "disabled"
 1407   1351   
            region = "us-east-1"
 1408   1352   
            endpoint = "https://example.com"
 1409   1353   
        }
 1410   1354   
        val expected = Endpoint(
 1411   1355   
            uri = Url.parse("https://example.com"),
 1412   1356   
        )
 1413   1357   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1414   1358   
        expectEqualEndpoints(expected, actual)
 1415   1359   
    }
 1416   1360   
 1417   1361   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1418   1362   
    @Test
 1419         -
    fun test86() = runTest {
        1363  +
    fun test82() = runTest {
 1420   1364   
        val params = DynamoDbEndpointParameters {
 1421   1365   
            useFips = false
 1422   1366   
            useDualStack = false
 1423   1367   
            accountId = "111111111111"
 1424   1368   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 1425   1369   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1426   1370   
            accountIdEndpointMode = "disabled"
 1427   1371   
            region = "us-east-1"
 1428   1372   
            endpoint = "https://example.com"
 1429   1373   
        }
 1430   1374   
        val expected = Endpoint(
 1431   1375   
            uri = Url.parse("https://example.com"),
 1432   1376   
        )
 1433   1377   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1434   1378   
        expectEqualEndpoints(expected, actual)
 1435   1379   
    }
 1436   1380   
 1437   1381   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1438   1382   
    @Test
 1439         -
    fun test87() = runTest {
        1383  +
    fun test83() = runTest {
 1440   1384   
        val params = DynamoDbEndpointParameters {
 1441   1385   
            useFips = false
 1442   1386   
            useDualStack = false
 1443   1387   
            accountId = "111111111111"
 1444   1388   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 1445   1389   
            resourceArnList = listOf("arn:aws:dynamodb:us-west-2:333333333333:table/table_name")
 1446   1390   
            accountIdEndpointMode = "disabled"
 1447   1391   
            region = "us-east-1"
 1448   1392   
            endpoint = "https://example.com"
 1449   1393   
        }
 1450   1394   
        val expected = Endpoint(
 1451   1395   
            uri = Url.parse("https://example.com"),
 1452   1396   
        )
 1453   1397   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1454   1398   
        expectEqualEndpoints(expected, actual)
 1455   1399   
    }
 1456   1400   
 1457   1401   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1458   1402   
    @Test
 1459         -
    fun test88() = runTest {
        1403  +
    fun test84() = runTest {
 1460   1404   
        val params = DynamoDbEndpointParameters {
 1461   1405   
            useFips = false
 1462   1406   
            useDualStack = false
 1463   1407   
            accountId = "111111111111"
 1464   1408   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 1465   1409   
            resourceArnList = listOf("arn:aws:s3:us-east-1:333333333333:stream/testStream")
 1466   1410   
            accountIdEndpointMode = "disabled"
 1467   1411   
            region = "us-east-1"
 1468   1412   
            endpoint = "https://example.com"
 1469   1413   
        }
 1470   1414   
        val expected = Endpoint(
 1471   1415   
            uri = Url.parse("https://example.com"),
 1472   1416   
        )
 1473   1417   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1474   1418   
        expectEqualEndpoints(expected, actual)
 1475   1419   
    }
 1476   1420   
 1477   1421   
    // {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1478   1422   
    @Test
 1479         -
    fun test89() = runTest {
        1423  +
    fun test85() = runTest {
 1480   1424   
        val params = DynamoDbEndpointParameters {
 1481   1425   
            useFips = false
 1482   1426   
            useDualStack = false
 1483   1427   
            accountId = ""
 1484   1428   
            accountIdEndpointMode = "disabled"
 1485   1429   
            region = "us-east-1"
 1486   1430   
            endpoint = "https://example.com"
 1487   1431   
        }
 1488   1432   
        val expected = Endpoint(
 1489   1433   
            uri = Url.parse("https://example.com"),
 1490   1434   
        )
 1491   1435   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1492   1436   
        expectEqualEndpoints(expected, actual)
 1493   1437   
    }
 1494   1438   
 1495   1439   
    // {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1496   1440   
    @Test
 1497         -
    fun test90() = runTest {
        1441  +
    fun test86() = runTest {
 1498   1442   
        val params = DynamoDbEndpointParameters {
 1499   1443   
            useFips = true
 1500   1444   
            useDualStack = true
 1501   1445   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1502   1446   
            accountIdEndpointMode = "disabled"
 1503   1447   
            region = "us-east-1"
 1504   1448   
            endpoint = "https://example.com"
 1505   1449   
        }
 1506   1450   
        val ex = assertFailsWith<EndpointProviderException> {
 1507   1451   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1508   1452   
        }
 1509   1453   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 1510   1454   
    }
 1511   1455   
 1512   1456   
    // {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1513   1457   
    @Test
 1514         -
    fun test91() = runTest {
        1458  +
    fun test87() = runTest {
 1515   1459   
        val params = DynamoDbEndpointParameters {
 1516   1460   
            useFips = true
 1517   1461   
            useDualStack = false
 1518   1462   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1519   1463   
            accountIdEndpointMode = "disabled"
 1520   1464   
            region = "us-east-1"
 1521   1465   
            endpoint = "https://example.com"
 1522   1466   
        }
 1523   1467   
        val ex = assertFailsWith<EndpointProviderException> {
 1524   1468   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1525   1469   
        }
 1526   1470   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 1527   1471   
    }
 1528   1472   
 1529   1473   
    // {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1530   1474   
    @Test
 1531         -
    fun test92() = runTest {
        1475  +
    fun test88() = runTest {
 1532   1476   
        val params = DynamoDbEndpointParameters {
 1533   1477   
            useFips = false
 1534   1478   
            useDualStack = true
 1535   1479   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1536   1480   
            accountIdEndpointMode = "disabled"
 1537   1481   
            region = "us-east-1"
 1538   1482   
            endpoint = "https://example.com"
 1539   1483   
        }
 1540   1484   
        val ex = assertFailsWith<EndpointProviderException> {
 1541   1485   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1542   1486   
        }
 1543   1487   
        assertEquals("Invalid Configuration: Dualstack and custom endpoint are not supported", ex.message)
 1544   1488   
    }
 1545   1489   
 1546   1490   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1547   1491   
    @Test
 1548         -
    fun test93() = runTest {
        1492  +
    fun test89() = runTest {
 1549   1493   
        val params = DynamoDbEndpointParameters {
 1550   1494   
            useFips = false
 1551   1495   
            useDualStack = false
 1552   1496   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1553   1497   
            accountIdEndpointMode = "disabled"
 1554   1498   
            region = "us-east-1"
 1555   1499   
            endpoint = "https://example.com"
 1556   1500   
        }
 1557   1501   
        val expected = Endpoint(
 1558   1502   
            uri = Url.parse("https://example.com"),
 1559   1503   
        )
 1560   1504   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1561   1505   
        expectEqualEndpoints(expected, actual)
 1562   1506   
    }
 1563   1507   
 1564   1508   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1565   1509   
    @Test
 1566         -
    fun test94() = runTest {
        1510  +
    fun test90() = runTest {
 1567   1511   
        val params = DynamoDbEndpointParameters {
 1568   1512   
            useFips = false
 1569   1513   
            useDualStack = false
 1570   1514   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 1571   1515   
            accountIdEndpointMode = "disabled"
 1572   1516   
            region = "us-east-1"
 1573   1517   
            endpoint = "https://example.com"
 1574   1518   
        }
 1575   1519   
        val expected = Endpoint(
 1576   1520   
            uri = Url.parse("https://example.com"),
 1577   1521   
        )
 1578   1522   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1579   1523   
        expectEqualEndpoints(expected, actual)
 1580   1524   
    }
 1581   1525   
 1582   1526   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1583   1527   
    @Test
 1584         -
    fun test95() = runTest {
        1528  +
    fun test91() = runTest {
 1585   1529   
        val params = DynamoDbEndpointParameters {
 1586   1530   
            useFips = false
 1587   1531   
            useDualStack = false
 1588   1532   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 1589   1533   
            accountIdEndpointMode = "disabled"
 1590   1534   
            region = "us-east-1"
 1591   1535   
            endpoint = "https://example.com"
 1592   1536   
        }
 1593   1537   
        val expected = Endpoint(
 1594   1538   
            uri = Url.parse("https://example.com"),
 1595   1539   
        )
 1596   1540   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1597   1541   
        expectEqualEndpoints(expected, actual)
 1598   1542   
    }
 1599   1543   
 1600   1544   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1601   1545   
    @Test
 1602         -
    fun test96() = runTest {
        1546  +
    fun test92() = runTest {
 1603   1547   
        val params = DynamoDbEndpointParameters {
 1604   1548   
            useFips = false
 1605   1549   
            useDualStack = false
 1606   1550   
            resourceArn = ""
 1607   1551   
            accountIdEndpointMode = "disabled"
 1608   1552   
            region = "us-east-1"
 1609   1553   
            endpoint = "https://example.com"
 1610   1554   
        }
 1611   1555   
        val expected = Endpoint(
 1612   1556   
            uri = Url.parse("https://example.com"),
 1613   1557   
        )
 1614   1558   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1615   1559   
        expectEqualEndpoints(expected, actual)
 1616   1560   
    }
 1617   1561   
 1618   1562   
    // {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1619   1563   
    @Test
 1620         -
    fun test97() = runTest {
        1564  +
    fun test93() = runTest {
 1621   1565   
        val params = DynamoDbEndpointParameters {
 1622   1566   
            useFips = true
 1623   1567   
            useDualStack = true
 1624   1568   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1625   1569   
            accountIdEndpointMode = "disabled"
 1626   1570   
            region = "us-east-1"
 1627   1571   
            endpoint = "https://example.com"
 1628   1572   
        }
 1629   1573   
        val ex = assertFailsWith<EndpointProviderException> {
 1630   1574   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1631   1575   
        }
 1632   1576   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 1633   1577   
    }
 1634   1578   
 1635   1579   
    // {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1636   1580   
    @Test
 1637         -
    fun test98() = runTest {
        1581  +
    fun test94() = runTest {
 1638   1582   
        val params = DynamoDbEndpointParameters {
 1639   1583   
            useFips = true
 1640   1584   
            useDualStack = false
 1641   1585   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1642   1586   
            accountIdEndpointMode = "disabled"
 1643   1587   
            region = "us-east-1"
 1644   1588   
            endpoint = "https://example.com"
 1645   1589   
        }
 1646   1590   
        val ex = assertFailsWith<EndpointProviderException> {
 1647   1591   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1648   1592   
        }
 1649   1593   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 1650   1594   
    }
 1651   1595   
 1652   1596   
    // {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1653   1597   
    @Test
 1654         -
    fun test99() = runTest {
        1598  +
    fun test95() = runTest {
 1655   1599   
        val params = DynamoDbEndpointParameters {
 1656   1600   
            useFips = false
 1657   1601   
            useDualStack = true
 1658   1602   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1659   1603   
            accountIdEndpointMode = "disabled"
 1660   1604   
            region = "us-east-1"
 1661   1605   
            endpoint = "https://example.com"
 1662   1606   
        }
 1663   1607   
        val ex = assertFailsWith<EndpointProviderException> {
 1664   1608   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1665   1609   
        }
 1666   1610   
        assertEquals("Invalid Configuration: Dualstack and custom endpoint are not supported", ex.message)
 1667   1611   
    }
 1668   1612   
 1669   1613   
    // {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1670   1614   
    @Test
 1671         -
    fun test100() = runTest {
        1615  +
    fun test96() = runTest {
 1672   1616   
        val params = DynamoDbEndpointParameters {
 1673   1617   
            useFips = false
 1674   1618   
            useDualStack = false
 1675   1619   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1676   1620   
            accountIdEndpointMode = "disabled"
 1677   1621   
            region = "us-east-1"
 1678   1622   
            endpoint = "https://example.com"
 1679   1623   
        }
 1680   1624   
        val expected = Endpoint(
 1681   1625   
            uri = Url.parse("https://example.com"),
 1682   1626   
        )
 1683   1627   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1684   1628   
        expectEqualEndpoints(expected, actual)
 1685   1629   
    }
 1686   1630   
 1687   1631   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1688   1632   
    @Test
 1689         -
    fun test101() = runTest {
        1633  +
    fun test97() = runTest {
 1690   1634   
        val params = DynamoDbEndpointParameters {
 1691   1635   
            useFips = false
 1692   1636   
            useDualStack = false
 1693   1637   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1694   1638   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1695   1639   
            accountIdEndpointMode = "disabled"
 1696   1640   
            region = "us-east-1"
 1697   1641   
            endpoint = "https://example.com"
 1698   1642   
        }
 1699   1643   
        val expected = Endpoint(
 1700   1644   
            uri = Url.parse("https://example.com"),
 1701   1645   
        )
 1702   1646   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1703   1647   
        expectEqualEndpoints(expected, actual)
 1704   1648   
    }
 1705   1649   
 1706   1650   
    // {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=disabled, Region=us-east-1, Endpoint=https://example.com}
 1707   1651   
    @Test
 1708         -
    fun test102() = runTest {
        1652  +
    fun test98() = runTest {
 1709   1653   
        val params = DynamoDbEndpointParameters {
 1710   1654   
            useFips = false
 1711   1655   
            useDualStack = false
 1712   1656   
            accountIdEndpointMode = "disabled"
 1713   1657   
            region = "us-east-1"
 1714   1658   
            endpoint = "https://example.com"
 1715   1659   
        }
 1716   1660   
        val expected = Endpoint(
 1717   1661   
            uri = Url.parse("https://example.com"),
 1718   1662   
        )
 1719   1663   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1720   1664   
        expectEqualEndpoints(expected, actual)
 1721   1665   
    }
 1722   1666   
 1723   1667   
    // {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1724   1668   
    @Test
 1725         -
    fun test103() = runTest {
        1669  +
    fun test99() = runTest {
 1726   1670   
        val params = DynamoDbEndpointParameters {
 1727   1671   
            useFips = true
 1728   1672   
            useDualStack = true
 1729   1673   
            accountId = "111111111111"
 1730   1674   
            accountIdEndpointMode = "required"
 1731   1675   
            region = "us-east-1"
 1732   1676   
            endpoint = "https://example.com"
 1733   1677   
        }
 1734   1678   
        val ex = assertFailsWith<EndpointProviderException> {
 1735   1679   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1736   1680   
        }
 1737   1681   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 1738   1682   
    }
 1739   1683   
 1740   1684   
    // {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1741   1685   
    @Test
 1742         -
    fun test104() = runTest {
        1686  +
    fun test100() = runTest {
 1743   1687   
        val params = DynamoDbEndpointParameters {
 1744   1688   
            useFips = true
 1745   1689   
            useDualStack = false
 1746   1690   
            accountId = "111111111111"
 1747   1691   
            accountIdEndpointMode = "required"
 1748   1692   
            region = "us-east-1"
 1749   1693   
            endpoint = "https://example.com"
 1750   1694   
        }
 1751   1695   
        val ex = assertFailsWith<EndpointProviderException> {
 1752   1696   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1753   1697   
        }
 1754   1698   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 1755   1699   
    }
 1756   1700   
 1757   1701   
    // {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1758   1702   
    @Test
 1759         -
    fun test105() = runTest {
        1703  +
    fun test101() = runTest {
 1760   1704   
        val params = DynamoDbEndpointParameters {
 1761   1705   
            useFips = false
 1762   1706   
            useDualStack = true
 1763   1707   
            accountId = "111111111111"
 1764   1708   
            accountIdEndpointMode = "required"
 1765   1709   
            region = "us-east-1"
 1766   1710   
            endpoint = "https://example.com"
 1767   1711   
        }
 1768   1712   
        val ex = assertFailsWith<EndpointProviderException> {
 1769   1713   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1770   1714   
        }
 1771   1715   
        assertEquals("Invalid Configuration: Dualstack and custom endpoint are not supported", ex.message)
 1772   1716   
    }
 1773   1717   
 1774   1718   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1775   1719   
    @Test
 1776         -
    fun test106() = runTest {
        1720  +
    fun test102() = runTest {
 1777   1721   
        val params = DynamoDbEndpointParameters {
 1778   1722   
            useFips = false
 1779   1723   
            useDualStack = false
 1780   1724   
            accountId = "111111111111"
 1781   1725   
            accountIdEndpointMode = "required"
 1782   1726   
            region = "us-east-1"
 1783   1727   
            endpoint = "https://example.com"
 1784   1728   
        }
 1785   1729   
        val expected = Endpoint(
 1786   1730   
            uri = Url.parse("https://example.com"),
 1787   1731   
        )
 1788   1732   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1789   1733   
        expectEqualEndpoints(expected, actual)
 1790   1734   
    }
 1791   1735   
 1792   1736   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1793   1737   
    @Test
 1794         -
    fun test107() = runTest {
        1738  +
    fun test103() = runTest {
 1795   1739   
        val params = DynamoDbEndpointParameters {
 1796   1740   
            useFips = false
 1797   1741   
            useDualStack = false
 1798   1742   
            accountId = "111111111111"
 1799   1743   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1800   1744   
            accountIdEndpointMode = "required"
 1801   1745   
            region = "us-east-1"
 1802   1746   
            endpoint = "https://example.com"
 1803   1747   
        }
 1804   1748   
        val expected = Endpoint(
 1805   1749   
            uri = Url.parse("https://example.com"),
 1806   1750   
        )
 1807   1751   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1808   1752   
        expectEqualEndpoints(expected, actual)
 1809   1753   
    }
 1810   1754   
 1811   1755   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1812   1756   
    @Test
 1813         -
    fun test108() = runTest {
        1757  +
    fun test104() = runTest {
 1814   1758   
        val params = DynamoDbEndpointParameters {
 1815   1759   
            useFips = false
 1816   1760   
            useDualStack = false
 1817   1761   
            accountId = "111111111111"
 1818   1762   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1819   1763   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1820   1764   
            accountIdEndpointMode = "required"
 1821   1765   
            region = "us-east-1"
 1822   1766   
            endpoint = "https://example.com"
 1823   1767   
        }
 1824   1768   
        val expected = Endpoint(
 1825   1769   
            uri = Url.parse("https://example.com"),
 1826   1770   
        )
 1827   1771   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1828   1772   
        expectEqualEndpoints(expected, actual)
 1829   1773   
    }
 1830   1774   
 1831   1775   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1832   1776   
    @Test
 1833         -
    fun test109() = runTest {
        1777  +
    fun test105() = runTest {
 1834   1778   
        val params = DynamoDbEndpointParameters {
 1835   1779   
            useFips = false
 1836   1780   
            useDualStack = false
 1837   1781   
            accountId = "111111111111"
 1838   1782   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 1839   1783   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1840   1784   
            accountIdEndpointMode = "required"
 1841   1785   
            region = "us-east-1"
 1842   1786   
            endpoint = "https://example.com"
 1843   1787   
        }
 1844   1788   
        val expected = Endpoint(
 1845   1789   
            uri = Url.parse("https://example.com"),
 1846   1790   
        )
 1847   1791   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1848   1792   
        expectEqualEndpoints(expected, actual)
 1849   1793   
    }
 1850   1794   
 1851   1795   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1852   1796   
    @Test
 1853         -
    fun test110() = runTest {
        1797  +
    fun test106() = runTest {
 1854   1798   
        val params = DynamoDbEndpointParameters {
 1855   1799   
            useFips = false
 1856   1800   
            useDualStack = false
 1857   1801   
            accountId = "111111111111"
 1858   1802   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 1859   1803   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 1860   1804   
            accountIdEndpointMode = "required"
 1861   1805   
            region = "us-east-1"
 1862   1806   
            endpoint = "https://example.com"
 1863   1807   
        }
 1864   1808   
        val expected = Endpoint(
 1865   1809   
            uri = Url.parse("https://example.com"),
 1866   1810   
        )
 1867   1811   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1868   1812   
        expectEqualEndpoints(expected, actual)
 1869   1813   
    }
 1870   1814   
 1871   1815   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1872   1816   
    @Test
 1873         -
    fun test111() = runTest {
        1817  +
    fun test107() = runTest {
 1874   1818   
        val params = DynamoDbEndpointParameters {
 1875   1819   
            useFips = false
 1876   1820   
            useDualStack = false
 1877   1821   
            accountId = "111111111111"
 1878   1822   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 1879   1823   
            resourceArnList = listOf("arn:aws:dynamodb:us-west-2:333333333333:table/table_name")
 1880   1824   
            accountIdEndpointMode = "required"
 1881   1825   
            region = "us-east-1"
 1882   1826   
            endpoint = "https://example.com"
 1883   1827   
        }
 1884   1828   
        val expected = Endpoint(
 1885   1829   
            uri = Url.parse("https://example.com"),
 1886   1830   
        )
 1887   1831   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1888   1832   
        expectEqualEndpoints(expected, actual)
 1889   1833   
    }
 1890   1834   
 1891   1835   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1892   1836   
    @Test
 1893         -
    fun test112() = runTest {
        1837  +
    fun test108() = runTest {
 1894   1838   
        val params = DynamoDbEndpointParameters {
 1895   1839   
            useFips = false
 1896   1840   
            useDualStack = false
 1897   1841   
            accountId = "111111111111"
 1898   1842   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 1899   1843   
            resourceArnList = listOf("arn:aws:s3:us-east-1:333333333333:stream/testStream")
 1900   1844   
            accountIdEndpointMode = "required"
 1901   1845   
            region = "us-east-1"
 1902   1846   
            endpoint = "https://example.com"
 1903   1847   
        }
 1904   1848   
        val expected = Endpoint(
 1905   1849   
            uri = Url.parse("https://example.com"),
 1906   1850   
        )
 1907   1851   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1908   1852   
        expectEqualEndpoints(expected, actual)
 1909   1853   
    }
 1910   1854   
 1911   1855   
    // {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1912   1856   
    @Test
 1913         -
    fun test113() = runTest {
        1857  +
    fun test109() = runTest {
 1914   1858   
        val params = DynamoDbEndpointParameters {
 1915   1859   
            useFips = false
 1916   1860   
            useDualStack = false
 1917   1861   
            accountId = ""
 1918   1862   
            accountIdEndpointMode = "required"
 1919   1863   
            region = "us-east-1"
 1920   1864   
            endpoint = "https://example.com"
 1921   1865   
        }
 1922   1866   
        val expected = Endpoint(
 1923   1867   
            uri = Url.parse("https://example.com"),
 1924   1868   
        )
 1925   1869   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1926   1870   
        expectEqualEndpoints(expected, actual)
 1927   1871   
    }
 1928   1872   
 1929   1873   
    // {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1930   1874   
    @Test
 1931         -
    fun test114() = runTest {
        1875  +
    fun test110() = runTest {
 1932   1876   
        val params = DynamoDbEndpointParameters {
 1933   1877   
            useFips = true
 1934   1878   
            useDualStack = true
 1935   1879   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1936   1880   
            accountIdEndpointMode = "required"
 1937   1881   
            region = "us-east-1"
 1938   1882   
            endpoint = "https://example.com"
 1939   1883   
        }
 1940   1884   
        val ex = assertFailsWith<EndpointProviderException> {
 1941   1885   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1942   1886   
        }
 1943   1887   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 1944   1888   
    }
 1945   1889   
 1946   1890   
    // {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1947   1891   
    @Test
 1948         -
    fun test115() = runTest {
        1892  +
    fun test111() = runTest {
 1949   1893   
        val params = DynamoDbEndpointParameters {
 1950   1894   
            useFips = true
 1951   1895   
            useDualStack = false
 1952   1896   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1953   1897   
            accountIdEndpointMode = "required"
 1954   1898   
            region = "us-east-1"
 1955   1899   
            endpoint = "https://example.com"
 1956   1900   
        }
 1957   1901   
        val ex = assertFailsWith<EndpointProviderException> {
 1958   1902   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1959   1903   
        }
 1960   1904   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 1961   1905   
    }
 1962   1906   
 1963   1907   
    // {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1964   1908   
    @Test
 1965         -
    fun test116() = runTest {
        1909  +
    fun test112() = runTest {
 1966   1910   
        val params = DynamoDbEndpointParameters {
 1967   1911   
            useFips = false
 1968   1912   
            useDualStack = true
 1969   1913   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1970   1914   
            accountIdEndpointMode = "required"
 1971   1915   
            region = "us-east-1"
 1972   1916   
            endpoint = "https://example.com"
 1973   1917   
        }
 1974   1918   
        val ex = assertFailsWith<EndpointProviderException> {
 1975   1919   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1976   1920   
        }
 1977   1921   
        assertEquals("Invalid Configuration: Dualstack and custom endpoint are not supported", ex.message)
 1978   1922   
    }
 1979   1923   
 1980   1924   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1981   1925   
    @Test
 1982         -
    fun test117() = runTest {
        1926  +
    fun test113() = runTest {
 1983   1927   
        val params = DynamoDbEndpointParameters {
 1984   1928   
            useFips = false
 1985   1929   
            useDualStack = false
 1986   1930   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 1987   1931   
            accountIdEndpointMode = "required"
 1988   1932   
            region = "us-east-1"
 1989   1933   
            endpoint = "https://example.com"
 1990   1934   
        }
 1991   1935   
        val expected = Endpoint(
 1992   1936   
            uri = Url.parse("https://example.com"),
 1993   1937   
        )
 1994   1938   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 1995   1939   
        expectEqualEndpoints(expected, actual)
 1996   1940   
    }
 1997   1941   
 1998   1942   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 1999   1943   
    @Test
 2000         -
    fun test118() = runTest {
        1944  +
    fun test114() = runTest {
 2001   1945   
        val params = DynamoDbEndpointParameters {
 2002   1946   
            useFips = false
 2003   1947   
            useDualStack = false
 2004   1948   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 2005   1949   
            accountIdEndpointMode = "required"
 2006   1950   
            region = "us-east-1"
 2007   1951   
            endpoint = "https://example.com"
 2008   1952   
        }
 2009   1953   
        val expected = Endpoint(
 2010   1954   
            uri = Url.parse("https://example.com"),
 2011   1955   
        )
 2012   1956   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2013   1957   
        expectEqualEndpoints(expected, actual)
 2014   1958   
    }
 2015   1959   
 2016   1960   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 2017   1961   
    @Test
 2018         -
    fun test119() = runTest {
        1962  +
    fun test115() = runTest {
 2019   1963   
        val params = DynamoDbEndpointParameters {
 2020   1964   
            useFips = false
 2021   1965   
            useDualStack = false
 2022   1966   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 2023   1967   
            accountIdEndpointMode = "required"
 2024   1968   
            region = "us-east-1"
 2025   1969   
            endpoint = "https://example.com"
 2026   1970   
        }
 2027   1971   
        val expected = Endpoint(
 2028   1972   
            uri = Url.parse("https://example.com"),
 2029   1973   
        )
 2030   1974   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2031   1975   
        expectEqualEndpoints(expected, actual)
 2032   1976   
    }
 2033   1977   
 2034   1978   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 2035   1979   
    @Test
 2036         -
    fun test120() = runTest {
        1980  +
    fun test116() = runTest {
 2037   1981   
        val params = DynamoDbEndpointParameters {
 2038   1982   
            useFips = false
 2039   1983   
            useDualStack = false
 2040   1984   
            resourceArn = ""
 2041   1985   
            accountIdEndpointMode = "required"
 2042   1986   
            region = "us-east-1"
 2043   1987   
            endpoint = "https://example.com"
 2044   1988   
        }
 2045   1989   
        val expected = Endpoint(
 2046   1990   
            uri = Url.parse("https://example.com"),
 2047   1991   
        )
 2048   1992   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2049   1993   
        expectEqualEndpoints(expected, actual)
 2050   1994   
    }
 2051   1995   
 2052   1996   
    // {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 2053   1997   
    @Test
 2054         -
    fun test121() = runTest {
        1998  +
    fun test117() = runTest {
 2055   1999   
        val params = DynamoDbEndpointParameters {
 2056   2000   
            useFips = true
 2057   2001   
            useDualStack = true
 2058   2002   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2059   2003   
            accountIdEndpointMode = "required"
 2060   2004   
            region = "us-east-1"
 2061   2005   
            endpoint = "https://example.com"
 2062   2006   
        }
 2063   2007   
        val ex = assertFailsWith<EndpointProviderException> {
 2064   2008   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2065   2009   
        }
 2066   2010   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 2067   2011   
    }
 2068   2012   
 2069   2013   
    // {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 2070   2014   
    @Test
 2071         -
    fun test122() = runTest {
        2015  +
    fun test118() = runTest {
 2072   2016   
        val params = DynamoDbEndpointParameters {
 2073   2017   
            useFips = true
 2074   2018   
            useDualStack = false
 2075   2019   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2076   2020   
            accountIdEndpointMode = "required"
 2077   2021   
            region = "us-east-1"
 2078   2022   
            endpoint = "https://example.com"
 2079   2023   
        }
 2080   2024   
        val ex = assertFailsWith<EndpointProviderException> {
 2081   2025   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2082   2026   
        }
 2083   2027   
        assertEquals("Invalid Configuration: FIPS and custom endpoint are not supported", ex.message)
 2084   2028   
    }
 2085   2029   
 2086   2030   
    // {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 2087   2031   
    @Test
 2088         -
    fun test123() = runTest {
        2032  +
    fun test119() = runTest {
 2089   2033   
        val params = DynamoDbEndpointParameters {
 2090   2034   
            useFips = false
 2091   2035   
            useDualStack = true
 2092   2036   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2093   2037   
            accountIdEndpointMode = "required"
 2094   2038   
            region = "us-east-1"
 2095   2039   
            endpoint = "https://example.com"
 2096   2040   
        }
 2097   2041   
        val ex = assertFailsWith<EndpointProviderException> {
 2098   2042   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2099   2043   
        }
 2100   2044   
        assertEquals("Invalid Configuration: Dualstack and custom endpoint are not supported", ex.message)
 2101   2045   
    }
 2102   2046   
 2103   2047   
    // {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 2104   2048   
    @Test
 2105         -
    fun test124() = runTest {
        2049  +
    fun test120() = runTest {
 2106   2050   
        val params = DynamoDbEndpointParameters {
 2107   2051   
            useFips = false
 2108   2052   
            useDualStack = false
 2109   2053   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2110   2054   
            accountIdEndpointMode = "required"
 2111   2055   
            region = "us-east-1"
 2112   2056   
            endpoint = "https://example.com"
 2113   2057   
        }
 2114   2058   
        val expected = Endpoint(
 2115   2059   
            uri = Url.parse("https://example.com"),
 2116   2060   
        )
 2117   2061   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2118   2062   
        expectEqualEndpoints(expected, actual)
 2119   2063   
    }
 2120   2064   
 2121   2065   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 2122   2066   
    @Test
 2123         -
    fun test125() = runTest {
        2067  +
    fun test121() = runTest {
 2124   2068   
        val params = DynamoDbEndpointParameters {
 2125   2069   
            useFips = false
 2126   2070   
            useDualStack = false
 2127   2071   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 2128   2072   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2129   2073   
            accountIdEndpointMode = "required"
 2130   2074   
            region = "us-east-1"
 2131   2075   
            endpoint = "https://example.com"
 2132   2076   
        }
 2133   2077   
        val expected = Endpoint(
 2134   2078   
            uri = Url.parse("https://example.com"),
 2135   2079   
        )
 2136   2080   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2137   2081   
        expectEqualEndpoints(expected, actual)
 2138   2082   
    }
 2139   2083   
 2140   2084   
    // {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=required, Region=us-east-1, Endpoint=https://example.com}
 2141   2085   
    @Test
 2142         -
    fun test126() = runTest {
        2086  +
    fun test122() = runTest {
 2143   2087   
        val params = DynamoDbEndpointParameters {
 2144   2088   
            useFips = false
 2145   2089   
            useDualStack = false
 2146   2090   
            accountIdEndpointMode = "required"
 2147   2091   
            region = "us-east-1"
 2148   2092   
            endpoint = "https://example.com"
 2149   2093   
        }
 2150   2094   
        val expected = Endpoint(
 2151   2095   
            uri = Url.parse("https://example.com"),
 2152   2096   
        )
 2153   2097   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2154   2098   
        expectEqualEndpoints(expected, actual)
 2155   2099   
    }
 2156   2100   
 2157   2101   
    // {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=local}
 2158   2102   
    @Test
 2159         -
    fun test127() = runTest {
        2103  +
    fun test123() = runTest {
 2160   2104   
        val params = DynamoDbEndpointParameters {
 2161   2105   
            useFips = true
 2162   2106   
            useDualStack = true
 2163   2107   
            accountId = "111111111111"
 2164   2108   
            accountIdEndpointMode = "preferred"
 2165   2109   
            region = "local"
 2166   2110   
        }
 2167   2111   
        val ex = assertFailsWith<EndpointProviderException> {
 2168   2112   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2169   2113   
        }
 2170   2114   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 2171   2115   
    }
 2172   2116   
 2173   2117   
    // {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=local}
 2174   2118   
    @Test
 2175         -
    fun test128() = runTest {
        2119  +
    fun test124() = runTest {
 2176   2120   
        val params = DynamoDbEndpointParameters {
 2177   2121   
            useFips = true
 2178   2122   
            useDualStack = false
 2179   2123   
            accountId = "111111111111"
 2180   2124   
            accountIdEndpointMode = "preferred"
 2181   2125   
            region = "local"
 2182   2126   
        }
 2183   2127   
        val ex = assertFailsWith<EndpointProviderException> {
 2184   2128   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2185   2129   
        }
 2186   2130   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 2187   2131   
    }
 2188   2132   
 2189   2133   
    // {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=local}
 2190   2134   
    @Test
 2191         -
    fun test129() = runTest {
        2135  +
    fun test125() = runTest {
 2192   2136   
        val params = DynamoDbEndpointParameters {
 2193   2137   
            useFips = false
 2194   2138   
            useDualStack = true
 2195   2139   
            accountId = "111111111111"
 2196   2140   
            accountIdEndpointMode = "preferred"
 2197   2141   
            region = "local"
 2198   2142   
        }
 2199   2143   
        val ex = assertFailsWith<EndpointProviderException> {
 2200   2144   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2201   2145   
        }
 2202   2146   
        assertEquals("Invalid Configuration: Dualstack and local endpoint are not supported", ex.message)
 2203   2147   
    }
 2204   2148   
 2205   2149   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=local}
 2206   2150   
    @Test
 2207         -
    fun test130() = runTest {
        2151  +
    fun test126() = runTest {
 2208   2152   
        val params = DynamoDbEndpointParameters {
 2209   2153   
            useFips = false
 2210   2154   
            useDualStack = false
 2211   2155   
            accountId = "111111111111"
 2212   2156   
            accountIdEndpointMode = "preferred"
 2213   2157   
            region = "local"
 2214   2158   
        }
 2215   2159   
        val expected = Endpoint(
 2216   2160   
            uri = Url.parse("http://localhost:8000"),
 2217   2161   
            attributes = attributesOf {
 2218   2162   
                SigningContextAttributeKey to listOf(
 2219   2163   
                    sigV4(
 2220   2164   
                        serviceName = "dynamodb",
 2221   2165   
                        disableDoubleUriEncode = false,
 2222   2166   
                        signingRegion = "us-east-1",
 2223   2167   
                    ),
 2224   2168   
                )
 2225   2169   
            },
 2226   2170   
        )
 2227   2171   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2228   2172   
        expectEqualEndpoints(expected, actual)
 2229   2173   
    }
 2230   2174   
 2231   2175   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
 2232   2176   
    @Test
 2233         -
    fun test131() = runTest {
        2177  +
    fun test127() = runTest {
 2234   2178   
        val params = DynamoDbEndpointParameters {
 2235   2179   
            useFips = false
 2236   2180   
            useDualStack = false
 2237   2181   
            accountId = "111111111111"
 2238   2182   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2239   2183   
            accountIdEndpointMode = "preferred"
 2240   2184   
            region = "local"
 2241   2185   
        }
 2242   2186   
        val expected = Endpoint(
 2243   2187   
            uri = Url.parse("http://localhost:8000"),
 2244   2188   
            attributes = attributesOf {
 2245   2189   
                SigningContextAttributeKey to listOf(
 2246   2190   
                    sigV4(
 2247   2191   
                        serviceName = "dynamodb",
 2248   2192   
                        disableDoubleUriEncode = false,
 2249   2193   
                        signingRegion = "us-east-1",
 2250   2194   
                    ),
 2251   2195   
                )
 2252   2196   
            },
 2253   2197   
        )
 2254   2198   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2255   2199   
        expectEqualEndpoints(expected, actual)
 2256   2200   
    }
 2257   2201   
 2258   2202   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
 2259   2203   
    @Test
 2260         -
    fun test132() = runTest {
        2204  +
    fun test128() = runTest {
 2261   2205   
        val params = DynamoDbEndpointParameters {
 2262   2206   
            useFips = false
 2263   2207   
            useDualStack = false
 2264   2208   
            accountId = "111111111111"
 2265   2209   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 2266   2210   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2267   2211   
            accountIdEndpointMode = "preferred"
 2268   2212   
            region = "local"
 2269   2213   
        }
 2270   2214   
        val expected = Endpoint(
 2271   2215   
            uri = Url.parse("http://localhost:8000"),
 2272   2216   
            attributes = attributesOf {
 2273   2217   
                SigningContextAttributeKey to listOf(
 2274   2218   
                    sigV4(
 2275   2219   
                        serviceName = "dynamodb",
 2276   2220   
                        disableDoubleUriEncode = false,
 2277   2221   
                        signingRegion = "us-east-1",
 2278   2222   
                    ),
 2279   2223   
                )
 2280   2224   
            },
 2281   2225   
        )
 2282   2226   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2283   2227   
        expectEqualEndpoints(expected, actual)
 2284   2228   
    }
 2285   2229   
 2286   2230   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
 2287   2231   
    @Test
 2288         -
    fun test133() = runTest {
        2232  +
    fun test129() = runTest {
 2289   2233   
        val params = DynamoDbEndpointParameters {
 2290   2234   
            useFips = false
 2291   2235   
            useDualStack = false
 2292   2236   
            accountId = "111111111111"
 2293   2237   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 2294   2238   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2295   2239   
            accountIdEndpointMode = "preferred"
 2296   2240   
            region = "local"
 2297   2241   
        }
 2298   2242   
        val expected = Endpoint(
 2299   2243   
            uri = Url.parse("http://localhost:8000"),
 2300   2244   
            attributes = attributesOf {
 2301   2245   
                SigningContextAttributeKey to listOf(
 2302   2246   
                    sigV4(
 2303   2247   
                        serviceName = "dynamodb",
 2304   2248   
                        disableDoubleUriEncode = false,
 2305   2249   
                        signingRegion = "us-east-1",
 2306   2250   
                    ),
 2307   2251   
                )
 2308   2252   
            },
 2309   2253   
        )
 2310   2254   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2311   2255   
        expectEqualEndpoints(expected, actual)
 2312   2256   
    }
 2313   2257   
 2314   2258   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
 2315   2259   
    @Test
 2316         -
    fun test134() = runTest {
        2260  +
    fun test130() = runTest {
 2317   2261   
        val params = DynamoDbEndpointParameters {
 2318   2262   
            useFips = false
 2319   2263   
            useDualStack = false
 2320   2264   
            accountId = "111111111111"
 2321   2265   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 2322   2266   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2323   2267   
            accountIdEndpointMode = "preferred"
 2324   2268   
            region = "local"
 2325   2269   
        }
 2326   2270   
        val expected = Endpoint(
 2327   2271   
            uri = Url.parse("http://localhost:8000"),
 2328   2272   
            attributes = attributesOf {
 2329   2273   
                SigningContextAttributeKey to listOf(
 2330   2274   
                    sigV4(
 2331   2275   
                        serviceName = "dynamodb",
 2332   2276   
                        disableDoubleUriEncode = false,
 2333   2277   
                        signingRegion = "us-east-1",
 2334   2278   
                    ),
 2335   2279   
                )
 2336   2280   
            },
 2337   2281   
        )
 2338   2282   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2339   2283   
        expectEqualEndpoints(expected, actual)
 2340   2284   
    }
 2341   2285   
 2342   2286   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
 2343   2287   
    @Test
 2344         -
    fun test135() = runTest {
        2288  +
    fun test131() = runTest {
 2345   2289   
        val params = DynamoDbEndpointParameters {
 2346   2290   
            useFips = false
 2347   2291   
            useDualStack = false
 2348   2292   
            accountId = "111111111111"
 2349   2293   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 2350   2294   
            resourceArnList = listOf("arn:aws:dynamodb:us-west-2:333333333333:table/table_name")
 2351   2295   
            accountIdEndpointMode = "preferred"
 2352   2296   
            region = "local"
 2353   2297   
        }
 2354   2298   
        val expected = Endpoint(
 2355   2299   
            uri = Url.parse("http://localhost:8000"),
 2356   2300   
            attributes = attributesOf {
 2357   2301   
                SigningContextAttributeKey to listOf(
 2358   2302   
                    sigV4(
 2359   2303   
                        serviceName = "dynamodb",
 2360   2304   
                        disableDoubleUriEncode = false,
 2361   2305   
                        signingRegion = "us-east-1",
 2362   2306   
                    ),
 2363   2307   
                )
 2364   2308   
            },
 2365   2309   
        )
 2366   2310   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2367   2311   
        expectEqualEndpoints(expected, actual)
 2368   2312   
    }
 2369   2313   
 2370   2314   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=preferred, Region=local}
 2371   2315   
    @Test
 2372         -
    fun test136() = runTest {
        2316  +
    fun test132() = runTest {
 2373   2317   
        val params = DynamoDbEndpointParameters {
 2374   2318   
            useFips = false
 2375   2319   
            useDualStack = false
 2376   2320   
            accountId = "111111111111"
 2377   2321   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 2378   2322   
            resourceArnList = listOf("arn:aws:s3:us-east-1:333333333333:stream/testStream")
 2379   2323   
            accountIdEndpointMode = "preferred"
 2380   2324   
            region = "local"
 2381   2325   
        }
 2382   2326   
        val expected = Endpoint(
 2383   2327   
            uri = Url.parse("http://localhost:8000"),
 2384   2328   
            attributes = attributesOf {
 2385   2329   
                SigningContextAttributeKey to listOf(
 2386   2330   
                    sigV4(
 2387   2331   
                        serviceName = "dynamodb",
 2388   2332   
                        disableDoubleUriEncode = false,
 2389   2333   
                        signingRegion = "us-east-1",
 2390   2334   
                    ),
 2391   2335   
                )
 2392   2336   
            },
 2393   2337   
        )
 2394   2338   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2395   2339   
        expectEqualEndpoints(expected, actual)
 2396   2340   
    }
 2397   2341   
 2398   2342   
    // {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=preferred, Region=local}
 2399   2343   
    @Test
 2400         -
    fun test137() = runTest {
        2344  +
    fun test133() = runTest {
 2401   2345   
        val params = DynamoDbEndpointParameters {
 2402   2346   
            useFips = false
 2403   2347   
            useDualStack = false
 2404   2348   
            accountId = ""
 2405   2349   
            accountIdEndpointMode = "preferred"
 2406   2350   
            region = "local"
 2407   2351   
        }
 2408   2352   
        val expected = Endpoint(
 2409   2353   
            uri = Url.parse("http://localhost:8000"),
 2410   2354   
            attributes = attributesOf {
 2411   2355   
                SigningContextAttributeKey to listOf(
 2412   2356   
                    sigV4(
 2413   2357   
                        serviceName = "dynamodb",
 2414   2358   
                        disableDoubleUriEncode = false,
 2415   2359   
                        signingRegion = "us-east-1",
 2416   2360   
                    ),
 2417   2361   
                )
 2418   2362   
            },
 2419   2363   
        )
 2420   2364   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2421   2365   
        expectEqualEndpoints(expected, actual)
 2422   2366   
    }
 2423   2367   
 2424   2368   
    // {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=local}
 2425   2369   
    @Test
 2426         -
    fun test138() = runTest {
        2370  +
    fun test134() = runTest {
 2427   2371   
        val params = DynamoDbEndpointParameters {
 2428   2372   
            useFips = true
 2429   2373   
            useDualStack = true
 2430   2374   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 2431   2375   
            accountIdEndpointMode = "preferred"
 2432   2376   
            region = "local"
 2433   2377   
        }
 2434   2378   
        val ex = assertFailsWith<EndpointProviderException> {
 2435   2379   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2436   2380   
        }
 2437   2381   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 2438   2382   
    }
 2439   2383   
 2440   2384   
    // {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=local}
 2441   2385   
    @Test
 2442         -
    fun test139() = runTest {
        2386  +
    fun test135() = runTest {
 2443   2387   
        val params = DynamoDbEndpointParameters {
 2444   2388   
            useFips = true
 2445   2389   
            useDualStack = false
 2446   2390   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 2447   2391   
            accountIdEndpointMode = "preferred"
 2448   2392   
            region = "local"
 2449   2393   
        }
 2450   2394   
        val ex = assertFailsWith<EndpointProviderException> {
 2451   2395   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2452   2396   
        }
 2453   2397   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 2454   2398   
    }
 2455   2399   
 2456   2400   
    // {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=local}
 2457   2401   
    @Test
 2458         -
    fun test140() = runTest {
        2402  +
    fun test136() = runTest {
 2459   2403   
        val params = DynamoDbEndpointParameters {
 2460   2404   
            useFips = false
 2461   2405   
            useDualStack = true
 2462   2406   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 2463   2407   
            accountIdEndpointMode = "preferred"
 2464   2408   
            region = "local"
 2465   2409   
        }
 2466   2410   
        val ex = assertFailsWith<EndpointProviderException> {
 2467   2411   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2468   2412   
        }
 2469   2413   
        assertEquals("Invalid Configuration: Dualstack and local endpoint are not supported", ex.message)
 2470   2414   
    }
 2471   2415   
 2472   2416   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=local}
 2473   2417   
    @Test
 2474         -
    fun test141() = runTest {
        2418  +
    fun test137() = runTest {
 2475   2419   
        val params = DynamoDbEndpointParameters {
 2476   2420   
            useFips = false
 2477   2421   
            useDualStack = false
 2478   2422   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 2479   2423   
            accountIdEndpointMode = "preferred"
 2480   2424   
            region = "local"
 2481   2425   
        }
 2482   2426   
        val expected = Endpoint(
 2483   2427   
            uri = Url.parse("http://localhost:8000"),
 2484   2428   
            attributes = attributesOf {
 2485   2429   
                SigningContextAttributeKey to listOf(
 2486   2430   
                    sigV4(
 2487   2431   
                        serviceName = "dynamodb",
 2488   2432   
                        disableDoubleUriEncode = false,
 2489   2433   
                        signingRegion = "us-east-1",
 2490   2434   
                    ),
 2491   2435   
                )
 2492   2436   
            },
 2493   2437   
        )
 2494   2438   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2495   2439   
        expectEqualEndpoints(expected, actual)
 2496   2440   
    }
 2497   2441   
 2498   2442   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=local}
 2499   2443   
    @Test
 2500         -
    fun test142() = runTest {
        2444  +
    fun test138() = runTest {
 2501   2445   
        val params = DynamoDbEndpointParameters {
 2502   2446   
            useFips = false
 2503   2447   
            useDualStack = false
 2504   2448   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 2505   2449   
            accountIdEndpointMode = "preferred"
 2506   2450   
            region = "local"
 2507   2451   
        }
 2508   2452   
        val expected = Endpoint(
 2509   2453   
            uri = Url.parse("http://localhost:8000"),
 2510   2454   
            attributes = attributesOf {
 2511   2455   
                SigningContextAttributeKey to listOf(
 2512   2456   
                    sigV4(
 2513   2457   
                        serviceName = "dynamodb",
 2514   2458   
                        disableDoubleUriEncode = false,
 2515   2459   
                        signingRegion = "us-east-1",
 2516   2460   
                    ),
 2517   2461   
                )
 2518   2462   
            },
 2519   2463   
        )
 2520   2464   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2521   2465   
        expectEqualEndpoints(expected, actual)
 2522   2466   
    }
 2523   2467   
 2524   2468   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=preferred, Region=local}
 2525   2469   
    @Test
 2526         -
    fun test143() = runTest {
        2470  +
    fun test139() = runTest {
 2527   2471   
        val params = DynamoDbEndpointParameters {
 2528   2472   
            useFips = false
 2529   2473   
            useDualStack = false
 2530   2474   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 2531   2475   
            accountIdEndpointMode = "preferred"
 2532   2476   
            region = "local"
 2533   2477   
        }
 2534   2478   
        val expected = Endpoint(
 2535   2479   
            uri = Url.parse("http://localhost:8000"),
 2536   2480   
            attributes = attributesOf {
 2537   2481   
                SigningContextAttributeKey to listOf(
 2538   2482   
                    sigV4(
 2539   2483   
                        serviceName = "dynamodb",
 2540   2484   
                        disableDoubleUriEncode = false,
 2541   2485   
                        signingRegion = "us-east-1",
 2542   2486   
                    ),
 2543   2487   
                )
 2544   2488   
            },
 2545   2489   
        )
 2546   2490   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2547   2491   
        expectEqualEndpoints(expected, actual)
 2548   2492   
    }
 2549   2493   
 2550   2494   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=preferred, Region=local}
 2551   2495   
    @Test
 2552         -
    fun test144() = runTest {
        2496  +
    fun test140() = runTest {
 2553   2497   
        val params = DynamoDbEndpointParameters {
 2554   2498   
            useFips = false
 2555   2499   
            useDualStack = false
 2556   2500   
            resourceArn = ""
 2557   2501   
            accountIdEndpointMode = "preferred"
 2558   2502   
            region = "local"
 2559   2503   
        }
 2560   2504   
        val expected = Endpoint(
 2561   2505   
            uri = Url.parse("http://localhost:8000"),
 2562   2506   
            attributes = attributesOf {
 2563   2507   
                SigningContextAttributeKey to listOf(
 2564   2508   
                    sigV4(
 2565   2509   
                        serviceName = "dynamodb",
 2566   2510   
                        disableDoubleUriEncode = false,
 2567   2511   
                        signingRegion = "us-east-1",
 2568   2512   
                    ),
 2569   2513   
                )
 2570   2514   
            },
 2571   2515   
        )
 2572   2516   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2573   2517   
        expectEqualEndpoints(expected, actual)
 2574   2518   
    }
 2575   2519   
 2576   2520   
    // {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
 2577   2521   
    @Test
 2578         -
    fun test145() = runTest {
        2522  +
    fun test141() = runTest {
 2579   2523   
        val params = DynamoDbEndpointParameters {
 2580   2524   
            useFips = true
 2581   2525   
            useDualStack = true
 2582   2526   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2583   2527   
            accountIdEndpointMode = "preferred"
 2584   2528   
            region = "local"
 2585   2529   
        }
 2586   2530   
        val ex = assertFailsWith<EndpointProviderException> {
 2587   2531   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2588   2532   
        }
 2589   2533   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 2590   2534   
    }
 2591   2535   
 2592   2536   
    // {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
 2593   2537   
    @Test
 2594         -
    fun test146() = runTest {
        2538  +
    fun test142() = runTest {
 2595   2539   
        val params = DynamoDbEndpointParameters {
 2596   2540   
            useFips = true
 2597   2541   
            useDualStack = false
 2598   2542   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2599   2543   
            accountIdEndpointMode = "preferred"
 2600   2544   
            region = "local"
 2601   2545   
        }
 2602   2546   
        val ex = assertFailsWith<EndpointProviderException> {
 2603   2547   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2604   2548   
        }
 2605   2549   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 2606   2550   
    }
 2607   2551   
 2608   2552   
    // {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
 2609   2553   
    @Test
 2610         -
    fun test147() = runTest {
        2554  +
    fun test143() = runTest {
 2611   2555   
        val params = DynamoDbEndpointParameters {
 2612   2556   
            useFips = false
 2613   2557   
            useDualStack = true
 2614   2558   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2615   2559   
            accountIdEndpointMode = "preferred"
 2616   2560   
            region = "local"
 2617   2561   
        }
 2618   2562   
        val ex = assertFailsWith<EndpointProviderException> {
 2619   2563   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2620   2564   
        }
 2621   2565   
        assertEquals("Invalid Configuration: Dualstack and local endpoint are not supported", ex.message)
 2622   2566   
    }
 2623   2567   
 2624   2568   
    // {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
 2625   2569   
    @Test
 2626         -
    fun test148() = runTest {
        2570  +
    fun test144() = runTest {
 2627   2571   
        val params = DynamoDbEndpointParameters {
 2628   2572   
            useFips = false
 2629   2573   
            useDualStack = false
 2630   2574   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2631   2575   
            accountIdEndpointMode = "preferred"
 2632   2576   
            region = "local"
 2633   2577   
        }
 2634   2578   
        val expected = Endpoint(
 2635   2579   
            uri = Url.parse("http://localhost:8000"),
 2636   2580   
            attributes = attributesOf {
 2637   2581   
                SigningContextAttributeKey to listOf(
 2638   2582   
                    sigV4(
 2639   2583   
                        serviceName = "dynamodb",
 2640   2584   
                        disableDoubleUriEncode = false,
 2641   2585   
                        signingRegion = "us-east-1",
 2642   2586   
                    ),
 2643   2587   
                )
 2644   2588   
            },
 2645   2589   
        )
 2646   2590   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2647   2591   
        expectEqualEndpoints(expected, actual)
 2648   2592   
    }
 2649   2593   
 2650   2594   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=local}
 2651   2595   
    @Test
 2652         -
    fun test149() = runTest {
        2596  +
    fun test145() = runTest {
 2653   2597   
        val params = DynamoDbEndpointParameters {
 2654   2598   
            useFips = false
 2655   2599   
            useDualStack = false
 2656   2600   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 2657   2601   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2658   2602   
            accountIdEndpointMode = "preferred"
 2659   2603   
            region = "local"
 2660   2604   
        }
 2661   2605   
        val expected = Endpoint(
 2662   2606   
            uri = Url.parse("http://localhost:8000"),
 2663   2607   
            attributes = attributesOf {
 2664   2608   
                SigningContextAttributeKey to listOf(
 2665   2609   
                    sigV4(
 2666   2610   
                        serviceName = "dynamodb",
 2667   2611   
                        disableDoubleUriEncode = false,
 2668   2612   
                        signingRegion = "us-east-1",
 2669   2613   
                    ),
 2670   2614   
                )
 2671   2615   
            },
 2672   2616   
        )
 2673   2617   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2674   2618   
        expectEqualEndpoints(expected, actual)
 2675   2619   
    }
 2676   2620   
 2677   2621   
    // {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=preferred, Region=local}
 2678   2622   
    @Test
 2679         -
    fun test150() = runTest {
        2623  +
    fun test146() = runTest {
 2680   2624   
        val params = DynamoDbEndpointParameters {
 2681   2625   
            useFips = false
 2682   2626   
            useDualStack = false
 2683   2627   
            accountIdEndpointMode = "preferred"
 2684   2628   
            region = "local"
 2685   2629   
        }
 2686   2630   
        val expected = Endpoint(
 2687   2631   
            uri = Url.parse("http://localhost:8000"),
 2688   2632   
            attributes = attributesOf {
 2689   2633   
                SigningContextAttributeKey to listOf(
 2690   2634   
                    sigV4(
 2691   2635   
                        serviceName = "dynamodb",
 2692   2636   
                        disableDoubleUriEncode = false,
 2693   2637   
                        signingRegion = "us-east-1",
 2694   2638   
                    ),
 2695   2639   
                )
 2696   2640   
            },
 2697   2641   
        )
 2698   2642   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2699   2643   
        expectEqualEndpoints(expected, actual)
 2700   2644   
    }
 2701   2645   
 2702   2646   
    // {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=local}
 2703   2647   
    @Test
 2704         -
    fun test151() = runTest {
        2648  +
    fun test147() = runTest {
 2705   2649   
        val params = DynamoDbEndpointParameters {
 2706   2650   
            useFips = true
 2707   2651   
            useDualStack = true
 2708   2652   
            accountId = "111111111111"
 2709   2653   
            accountIdEndpointMode = "disabled"
 2710   2654   
            region = "local"
 2711   2655   
        }
 2712   2656   
        val ex = assertFailsWith<EndpointProviderException> {
 2713   2657   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2714   2658   
        }
 2715   2659   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 2716   2660   
    }
 2717   2661   
 2718   2662   
    // {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=local}
 2719   2663   
    @Test
 2720         -
    fun test152() = runTest {
        2664  +
    fun test148() = runTest {
 2721   2665   
        val params = DynamoDbEndpointParameters {
 2722   2666   
            useFips = true
 2723   2667   
            useDualStack = false
 2724   2668   
            accountId = "111111111111"
 2725   2669   
            accountIdEndpointMode = "disabled"
 2726   2670   
            region = "local"
 2727   2671   
        }
 2728   2672   
        val ex = assertFailsWith<EndpointProviderException> {
 2729   2673   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2730   2674   
        }
 2731   2675   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 2732   2676   
    }
 2733   2677   
 2734   2678   
    // {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=local}
 2735   2679   
    @Test
 2736         -
    fun test153() = runTest {
        2680  +
    fun test149() = runTest {
 2737   2681   
        val params = DynamoDbEndpointParameters {
 2738   2682   
            useFips = false
 2739   2683   
            useDualStack = true
 2740   2684   
            accountId = "111111111111"
 2741   2685   
            accountIdEndpointMode = "disabled"
 2742   2686   
            region = "local"
 2743   2687   
        }
 2744   2688   
        val ex = assertFailsWith<EndpointProviderException> {
 2745   2689   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2746   2690   
        }
 2747   2691   
        assertEquals("Invalid Configuration: Dualstack and local endpoint are not supported", ex.message)
 2748   2692   
    }
 2749   2693   
 2750   2694   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=local}
 2751   2695   
    @Test
 2752         -
    fun test154() = runTest {
        2696  +
    fun test150() = runTest {
 2753   2697   
        val params = DynamoDbEndpointParameters {
 2754   2698   
            useFips = false
 2755   2699   
            useDualStack = false
 2756   2700   
            accountId = "111111111111"
 2757   2701   
            accountIdEndpointMode = "disabled"
 2758   2702   
            region = "local"
 2759   2703   
        }
 2760   2704   
        val expected = Endpoint(
 2761   2705   
            uri = Url.parse("http://localhost:8000"),
 2762   2706   
            attributes = attributesOf {
 2763   2707   
                SigningContextAttributeKey to listOf(
 2764   2708   
                    sigV4(
 2765   2709   
                        serviceName = "dynamodb",
 2766   2710   
                        disableDoubleUriEncode = false,
 2767   2711   
                        signingRegion = "us-east-1",
 2768   2712   
                    ),
 2769   2713   
                )
 2770   2714   
            },
 2771   2715   
        )
 2772   2716   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2773   2717   
        expectEqualEndpoints(expected, actual)
 2774   2718   
    }
 2775   2719   
 2776   2720   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
 2777   2721   
    @Test
 2778         -
    fun test155() = runTest {
        2722  +
    fun test151() = runTest {
 2779   2723   
        val params = DynamoDbEndpointParameters {
 2780   2724   
            useFips = false
 2781   2725   
            useDualStack = false
 2782   2726   
            accountId = "111111111111"
 2783   2727   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2784   2728   
            accountIdEndpointMode = "disabled"
 2785   2729   
            region = "local"
 2786   2730   
        }
 2787   2731   
        val expected = Endpoint(
 2788   2732   
            uri = Url.parse("http://localhost:8000"),
 2789   2733   
            attributes = attributesOf {
 2790   2734   
                SigningContextAttributeKey to listOf(
 2791   2735   
                    sigV4(
 2792   2736   
                        serviceName = "dynamodb",
 2793   2737   
                        disableDoubleUriEncode = false,
 2794   2738   
                        signingRegion = "us-east-1",
 2795   2739   
                    ),
 2796   2740   
                )
 2797   2741   
            },
 2798   2742   
        )
 2799   2743   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2800   2744   
        expectEqualEndpoints(expected, actual)
 2801   2745   
    }
 2802   2746   
 2803   2747   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
 2804   2748   
    @Test
 2805         -
    fun test156() = runTest {
        2749  +
    fun test152() = runTest {
 2806   2750   
        val params = DynamoDbEndpointParameters {
 2807   2751   
            useFips = false
 2808   2752   
            useDualStack = false
 2809   2753   
            accountId = "111111111111"
 2810   2754   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 2811   2755   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2812   2756   
            accountIdEndpointMode = "disabled"
 2813   2757   
            region = "local"
 2814   2758   
        }
 2815   2759   
        val expected = Endpoint(
 2816   2760   
            uri = Url.parse("http://localhost:8000"),
 2817   2761   
            attributes = attributesOf {
 2818   2762   
                SigningContextAttributeKey to listOf(
 2819   2763   
                    sigV4(
 2820   2764   
                        serviceName = "dynamodb",
 2821   2765   
                        disableDoubleUriEncode = false,
 2822   2766   
                        signingRegion = "us-east-1",
 2823   2767   
                    ),
 2824   2768   
                )
 2825   2769   
            },
 2826   2770   
        )
 2827   2771   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2828   2772   
        expectEqualEndpoints(expected, actual)
 2829   2773   
    }
 2830   2774   
 2831   2775   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
 2832   2776   
    @Test
 2833         -
    fun test157() = runTest {
        2777  +
    fun test153() = runTest {
 2834   2778   
        val params = DynamoDbEndpointParameters {
 2835   2779   
            useFips = false
 2836   2780   
            useDualStack = false
 2837   2781   
            accountId = "111111111111"
 2838   2782   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 2839   2783   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2840   2784   
            accountIdEndpointMode = "disabled"
 2841   2785   
            region = "local"
 2842   2786   
        }
 2843   2787   
        val expected = Endpoint(
 2844   2788   
            uri = Url.parse("http://localhost:8000"),
 2845   2789   
            attributes = attributesOf {
 2846   2790   
                SigningContextAttributeKey to listOf(
 2847   2791   
                    sigV4(
 2848   2792   
                        serviceName = "dynamodb",
 2849   2793   
                        disableDoubleUriEncode = false,
 2850   2794   
                        signingRegion = "us-east-1",
 2851   2795   
                    ),
 2852   2796   
                )
 2853   2797   
            },
 2854   2798   
        )
 2855   2799   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2856   2800   
        expectEqualEndpoints(expected, actual)
 2857   2801   
    }
 2858   2802   
 2859   2803   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
 2860   2804   
    @Test
 2861         -
    fun test158() = runTest {
        2805  +
    fun test154() = runTest {
 2862   2806   
        val params = DynamoDbEndpointParameters {
 2863   2807   
            useFips = false
 2864   2808   
            useDualStack = false
 2865   2809   
            accountId = "111111111111"
 2866   2810   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 2867   2811   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 2868   2812   
            accountIdEndpointMode = "disabled"
 2869   2813   
            region = "local"
 2870   2814   
        }
 2871   2815   
        val expected = Endpoint(
 2872   2816   
            uri = Url.parse("http://localhost:8000"),
 2873   2817   
            attributes = attributesOf {
 2874   2818   
                SigningContextAttributeKey to listOf(
 2875   2819   
                    sigV4(
 2876   2820   
                        serviceName = "dynamodb",
 2877   2821   
                        disableDoubleUriEncode = false,
 2878   2822   
                        signingRegion = "us-east-1",
 2879   2823   
                    ),
 2880   2824   
                )
 2881   2825   
            },
 2882   2826   
        )
 2883   2827   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2884   2828   
        expectEqualEndpoints(expected, actual)
 2885   2829   
    }
 2886   2830   
 2887   2831   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
 2888   2832   
    @Test
 2889         -
    fun test159() = runTest {
        2833  +
    fun test155() = runTest {
 2890   2834   
        val params = DynamoDbEndpointParameters {
 2891   2835   
            useFips = false
 2892   2836   
            useDualStack = false
 2893   2837   
            accountId = "111111111111"
 2894   2838   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 2895   2839   
            resourceArnList = listOf("arn:aws:dynamodb:us-west-2:333333333333:table/table_name")
 2896   2840   
            accountIdEndpointMode = "disabled"
 2897   2841   
            region = "local"
 2898   2842   
        }
 2899   2843   
        val expected = Endpoint(
 2900   2844   
            uri = Url.parse("http://localhost:8000"),
 2901   2845   
            attributes = attributesOf {
 2902   2846   
                SigningContextAttributeKey to listOf(
 2903   2847   
                    sigV4(
 2904   2848   
                        serviceName = "dynamodb",
 2905   2849   
                        disableDoubleUriEncode = false,
 2906   2850   
                        signingRegion = "us-east-1",
 2907   2851   
                    ),
 2908   2852   
                )
 2909   2853   
            },
 2910   2854   
        )
 2911   2855   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2912   2856   
        expectEqualEndpoints(expected, actual)
 2913   2857   
    }
 2914   2858   
 2915   2859   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=disabled, Region=local}
 2916   2860   
    @Test
 2917         -
    fun test160() = runTest {
        2861  +
    fun test156() = runTest {
 2918   2862   
        val params = DynamoDbEndpointParameters {
 2919   2863   
            useFips = false
 2920   2864   
            useDualStack = false
 2921   2865   
            accountId = "111111111111"
 2922   2866   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 2923   2867   
            resourceArnList = listOf("arn:aws:s3:us-east-1:333333333333:stream/testStream")
 2924   2868   
            accountIdEndpointMode = "disabled"
 2925   2869   
            region = "local"
 2926   2870   
        }
 2927   2871   
        val expected = Endpoint(
 2928   2872   
            uri = Url.parse("http://localhost:8000"),
 2929   2873   
            attributes = attributesOf {
 2930   2874   
                SigningContextAttributeKey to listOf(
 2931   2875   
                    sigV4(
 2932   2876   
                        serviceName = "dynamodb",
 2933   2877   
                        disableDoubleUriEncode = false,
 2934   2878   
                        signingRegion = "us-east-1",
 2935   2879   
                    ),
 2936   2880   
                )
 2937   2881   
            },
 2938   2882   
        )
 2939   2883   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2940   2884   
        expectEqualEndpoints(expected, actual)
 2941   2885   
    }
 2942   2886   
 2943   2887   
    // {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=disabled, Region=local}
 2944   2888   
    @Test
 2945         -
    fun test161() = runTest {
        2889  +
    fun test157() = runTest {
 2946   2890   
        val params = DynamoDbEndpointParameters {
 2947   2891   
            useFips = false
 2948   2892   
            useDualStack = false
 2949   2893   
            accountId = ""
 2950   2894   
            accountIdEndpointMode = "disabled"
 2951   2895   
            region = "local"
 2952   2896   
        }
 2953   2897   
        val expected = Endpoint(
 2954   2898   
            uri = Url.parse("http://localhost:8000"),
 2955   2899   
            attributes = attributesOf {
 2956   2900   
                SigningContextAttributeKey to listOf(
 2957   2901   
                    sigV4(
 2958   2902   
                        serviceName = "dynamodb",
 2959   2903   
                        disableDoubleUriEncode = false,
 2960   2904   
                        signingRegion = "us-east-1",
 2961   2905   
                    ),
 2962   2906   
                )
 2963   2907   
            },
 2964   2908   
        )
 2965   2909   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2966   2910   
        expectEqualEndpoints(expected, actual)
 2967   2911   
    }
 2968   2912   
 2969   2913   
    // {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=local}
 2970   2914   
    @Test
 2971         -
    fun test162() = runTest {
        2915  +
    fun test158() = runTest {
 2972   2916   
        val params = DynamoDbEndpointParameters {
 2973   2917   
            useFips = true
 2974   2918   
            useDualStack = true
 2975   2919   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 2976   2920   
            accountIdEndpointMode = "disabled"
 2977   2921   
            region = "local"
 2978   2922   
        }
 2979   2923   
        val ex = assertFailsWith<EndpointProviderException> {
 2980   2924   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2981   2925   
        }
 2982   2926   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 2983   2927   
    }
 2984   2928   
 2985   2929   
    // {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=local}
 2986   2930   
    @Test
 2987         -
    fun test163() = runTest {
        2931  +
    fun test159() = runTest {
 2988   2932   
        val params = DynamoDbEndpointParameters {
 2989   2933   
            useFips = true
 2990   2934   
            useDualStack = false
 2991   2935   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 2992   2936   
            accountIdEndpointMode = "disabled"
 2993   2937   
            region = "local"
 2994   2938   
        }
 2995   2939   
        val ex = assertFailsWith<EndpointProviderException> {
 2996   2940   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 2997   2941   
        }
 2998   2942   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 2999   2943   
    }
 3000   2944   
 3001   2945   
    // {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=local}
 3002   2946   
    @Test
 3003         -
    fun test164() = runTest {
        2947  +
    fun test160() = runTest {
 3004   2948   
        val params = DynamoDbEndpointParameters {
 3005   2949   
            useFips = false
 3006   2950   
            useDualStack = true
 3007   2951   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 3008   2952   
            accountIdEndpointMode = "disabled"
 3009   2953   
            region = "local"
 3010   2954   
        }
 3011   2955   
        val ex = assertFailsWith<EndpointProviderException> {
 3012   2956   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3013   2957   
        }
 3014   2958   
        assertEquals("Invalid Configuration: Dualstack and local endpoint are not supported", ex.message)
 3015   2959   
    }
 3016   2960   
 3017   2961   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=local}
 3018   2962   
    @Test
 3019         -
    fun test165() = runTest {
        2963  +
    fun test161() = runTest {
 3020   2964   
        val params = DynamoDbEndpointParameters {
 3021   2965   
            useFips = false
 3022   2966   
            useDualStack = false
 3023   2967   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 3024   2968   
            accountIdEndpointMode = "disabled"
 3025   2969   
            region = "local"
 3026   2970   
        }
 3027   2971   
        val expected = Endpoint(
 3028   2972   
            uri = Url.parse("http://localhost:8000"),
 3029   2973   
            attributes = attributesOf {
 3030   2974   
                SigningContextAttributeKey to listOf(
 3031   2975   
                    sigV4(
 3032   2976   
                        serviceName = "dynamodb",
 3033   2977   
                        disableDoubleUriEncode = false,
 3034   2978   
                        signingRegion = "us-east-1",
 3035   2979   
                    ),
 3036   2980   
                )
 3037   2981   
            },
 3038   2982   
        )
 3039   2983   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3040   2984   
        expectEqualEndpoints(expected, actual)
 3041   2985   
    }
 3042   2986   
 3043   2987   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=local}
 3044   2988   
    @Test
 3045         -
    fun test166() = runTest {
        2989  +
    fun test162() = runTest {
 3046   2990   
        val params = DynamoDbEndpointParameters {
 3047   2991   
            useFips = false
 3048   2992   
            useDualStack = false
 3049   2993   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 3050   2994   
            accountIdEndpointMode = "disabled"
 3051   2995   
            region = "local"
 3052   2996   
        }
 3053   2997   
        val expected = Endpoint(
 3054   2998   
            uri = Url.parse("http://localhost:8000"),
 3055   2999   
            attributes = attributesOf {
 3056   3000   
                SigningContextAttributeKey to listOf(
 3057   3001   
                    sigV4(
 3058   3002   
                        serviceName = "dynamodb",
 3059   3003   
                        disableDoubleUriEncode = false,
 3060   3004   
                        signingRegion = "us-east-1",
 3061   3005   
                    ),
 3062   3006   
                )
 3063   3007   
            },
 3064   3008   
        )
 3065   3009   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3066   3010   
        expectEqualEndpoints(expected, actual)
 3067   3011   
    }
 3068   3012   
 3069   3013   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=disabled, Region=local}
 3070   3014   
    @Test
 3071         -
    fun test167() = runTest {
        3015  +
    fun test163() = runTest {
 3072   3016   
        val params = DynamoDbEndpointParameters {
 3073   3017   
            useFips = false
 3074   3018   
            useDualStack = false
 3075   3019   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 3076   3020   
            accountIdEndpointMode = "disabled"
 3077   3021   
            region = "local"
 3078   3022   
        }
 3079   3023   
        val expected = Endpoint(
 3080   3024   
            uri = Url.parse("http://localhost:8000"),
 3081   3025   
            attributes = attributesOf {
 3082   3026   
                SigningContextAttributeKey to listOf(
 3083   3027   
                    sigV4(
 3084   3028   
                        serviceName = "dynamodb",
 3085   3029   
                        disableDoubleUriEncode = false,
 3086   3030   
                        signingRegion = "us-east-1",
 3087   3031   
                    ),
 3088   3032   
                )
 3089   3033   
            },
 3090   3034   
        )
 3091   3035   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3092   3036   
        expectEqualEndpoints(expected, actual)
 3093   3037   
    }
 3094   3038   
 3095   3039   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=disabled, Region=local}
 3096   3040   
    @Test
 3097         -
    fun test168() = runTest {
        3041  +
    fun test164() = runTest {
 3098   3042   
        val params = DynamoDbEndpointParameters {
 3099   3043   
            useFips = false
 3100   3044   
            useDualStack = false
 3101   3045   
            resourceArn = ""
 3102   3046   
            accountIdEndpointMode = "disabled"
 3103   3047   
            region = "local"
 3104   3048   
        }
 3105   3049   
        val expected = Endpoint(
 3106   3050   
            uri = Url.parse("http://localhost:8000"),
 3107   3051   
            attributes = attributesOf {
 3108   3052   
                SigningContextAttributeKey to listOf(
 3109   3053   
                    sigV4(
 3110   3054   
                        serviceName = "dynamodb",
 3111   3055   
                        disableDoubleUriEncode = false,
 3112   3056   
                        signingRegion = "us-east-1",
 3113   3057   
                    ),
 3114   3058   
                )
 3115   3059   
            },
 3116   3060   
        )
 3117   3061   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3118   3062   
        expectEqualEndpoints(expected, actual)
 3119   3063   
    }
 3120   3064   
 3121   3065   
    // {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
 3122   3066   
    @Test
 3123         -
    fun test169() = runTest {
        3067  +
    fun test165() = runTest {
 3124   3068   
        val params = DynamoDbEndpointParameters {
 3125   3069   
            useFips = true
 3126   3070   
            useDualStack = true
 3127   3071   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3128   3072   
            accountIdEndpointMode = "disabled"
 3129   3073   
            region = "local"
 3130   3074   
        }
 3131   3075   
        val ex = assertFailsWith<EndpointProviderException> {
 3132   3076   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3133   3077   
        }
 3134   3078   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 3135   3079   
    }
 3136   3080   
 3137   3081   
    // {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
 3138   3082   
    @Test
 3139         -
    fun test170() = runTest {
        3083  +
    fun test166() = runTest {
 3140   3084   
        val params = DynamoDbEndpointParameters {
 3141   3085   
            useFips = true
 3142   3086   
            useDualStack = false
 3143   3087   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3144   3088   
            accountIdEndpointMode = "disabled"
 3145   3089   
            region = "local"
 3146   3090   
        }
 3147   3091   
        val ex = assertFailsWith<EndpointProviderException> {
 3148   3092   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3149   3093   
        }
 3150   3094   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 3151   3095   
    }
 3152   3096   
 3153   3097   
    // {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
 3154   3098   
    @Test
 3155         -
    fun test171() = runTest {
        3099  +
    fun test167() = runTest {
 3156   3100   
        val params = DynamoDbEndpointParameters {
 3157   3101   
            useFips = false
 3158   3102   
            useDualStack = true
 3159   3103   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3160   3104   
            accountIdEndpointMode = "disabled"
 3161   3105   
            region = "local"
 3162   3106   
        }
 3163   3107   
        val ex = assertFailsWith<EndpointProviderException> {
 3164   3108   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3165   3109   
        }
 3166   3110   
        assertEquals("Invalid Configuration: Dualstack and local endpoint are not supported", ex.message)
 3167   3111   
    }
 3168   3112   
 3169   3113   
    // {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
 3170   3114   
    @Test
 3171         -
    fun test172() = runTest {
        3115  +
    fun test168() = runTest {
 3172   3116   
        val params = DynamoDbEndpointParameters {
 3173   3117   
            useFips = false
 3174   3118   
            useDualStack = false
 3175   3119   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3176   3120   
            accountIdEndpointMode = "disabled"
 3177   3121   
            region = "local"
 3178   3122   
        }
 3179   3123   
        val expected = Endpoint(
 3180   3124   
            uri = Url.parse("http://localhost:8000"),
 3181   3125   
            attributes = attributesOf {
 3182   3126   
                SigningContextAttributeKey to listOf(
 3183   3127   
                    sigV4(
 3184   3128   
                        serviceName = "dynamodb",
 3185   3129   
                        disableDoubleUriEncode = false,
 3186   3130   
                        signingRegion = "us-east-1",
 3187   3131   
                    ),
 3188   3132   
                )
 3189   3133   
            },
 3190   3134   
        )
 3191   3135   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3192   3136   
        expectEqualEndpoints(expected, actual)
 3193   3137   
    }
 3194   3138   
 3195   3139   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=local}
 3196   3140   
    @Test
 3197         -
    fun test173() = runTest {
        3141  +
    fun test169() = runTest {
 3198   3142   
        val params = DynamoDbEndpointParameters {
 3199   3143   
            useFips = false
 3200   3144   
            useDualStack = false
 3201   3145   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 3202   3146   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3203   3147   
            accountIdEndpointMode = "disabled"
 3204   3148   
            region = "local"
 3205   3149   
        }
 3206   3150   
        val expected = Endpoint(
 3207   3151   
            uri = Url.parse("http://localhost:8000"),
 3208   3152   
            attributes = attributesOf {
 3209   3153   
                SigningContextAttributeKey to listOf(
 3210   3154   
                    sigV4(
 3211   3155   
                        serviceName = "dynamodb",
 3212   3156   
                        disableDoubleUriEncode = false,
 3213   3157   
                        signingRegion = "us-east-1",
 3214   3158   
                    ),
 3215   3159   
                )
 3216   3160   
            },
 3217   3161   
        )
 3218   3162   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3219   3163   
        expectEqualEndpoints(expected, actual)
 3220   3164   
    }
 3221   3165   
 3222   3166   
    // {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=disabled, Region=local}
 3223   3167   
    @Test
 3224         -
    fun test174() = runTest {
        3168  +
    fun test170() = runTest {
 3225   3169   
        val params = DynamoDbEndpointParameters {
 3226   3170   
            useFips = false
 3227   3171   
            useDualStack = false
 3228   3172   
            accountIdEndpointMode = "disabled"
 3229   3173   
            region = "local"
 3230   3174   
        }
 3231   3175   
        val expected = Endpoint(
 3232   3176   
            uri = Url.parse("http://localhost:8000"),
 3233   3177   
            attributes = attributesOf {
 3234   3178   
                SigningContextAttributeKey to listOf(
 3235   3179   
                    sigV4(
 3236   3180   
                        serviceName = "dynamodb",
 3237   3181   
                        disableDoubleUriEncode = false,
 3238   3182   
                        signingRegion = "us-east-1",
 3239   3183   
                    ),
 3240   3184   
                )
 3241   3185   
            },
 3242   3186   
        )
 3243   3187   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3244   3188   
        expectEqualEndpoints(expected, actual)
 3245   3189   
    }
 3246   3190   
 3247   3191   
    // {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=local}
 3248   3192   
    @Test
 3249         -
    fun test175() = runTest {
        3193  +
    fun test171() = runTest {
 3250   3194   
        val params = DynamoDbEndpointParameters {
 3251   3195   
            useFips = true
 3252   3196   
            useDualStack = true
 3253   3197   
            accountId = "111111111111"
 3254   3198   
            accountIdEndpointMode = "required"
 3255   3199   
            region = "local"
 3256   3200   
        }
 3257   3201   
        val ex = assertFailsWith<EndpointProviderException> {
 3258   3202   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3259   3203   
        }
 3260   3204   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 3261   3205   
    }
 3262   3206   
 3263   3207   
    // {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=local}
 3264   3208   
    @Test
 3265         -
    fun test176() = runTest {
        3209  +
    fun test172() = runTest {
 3266   3210   
        val params = DynamoDbEndpointParameters {
 3267   3211   
            useFips = true
 3268   3212   
            useDualStack = false
 3269   3213   
            accountId = "111111111111"
 3270   3214   
            accountIdEndpointMode = "required"
 3271   3215   
            region = "local"
 3272   3216   
        }
 3273   3217   
        val ex = assertFailsWith<EndpointProviderException> {
 3274   3218   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3275   3219   
        }
 3276   3220   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 3277   3221   
    }
 3278   3222   
 3279   3223   
    // {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=local}
 3280   3224   
    @Test
 3281         -
    fun test177() = runTest {
        3225  +
    fun test173() = runTest {
 3282   3226   
        val params = DynamoDbEndpointParameters {
 3283   3227   
            useFips = false
 3284   3228   
            useDualStack = true
 3285   3229   
            accountId = "111111111111"
 3286   3230   
            accountIdEndpointMode = "required"
 3287   3231   
            region = "local"
 3288   3232   
        }
 3289   3233   
        val ex = assertFailsWith<EndpointProviderException> {
 3290   3234   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3291   3235   
        }
 3292   3236   
        assertEquals("Invalid Configuration: Dualstack and local endpoint are not supported", ex.message)
 3293   3237   
    }
 3294   3238   
 3295   3239   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=local}
 3296   3240   
    @Test
 3297         -
    fun test178() = runTest {
        3241  +
    fun test174() = runTest {
 3298   3242   
        val params = DynamoDbEndpointParameters {
 3299   3243   
            useFips = false
 3300   3244   
            useDualStack = false
 3301   3245   
            accountId = "111111111111"
 3302   3246   
            accountIdEndpointMode = "required"
 3303   3247   
            region = "local"
 3304   3248   
        }
 3305   3249   
        val expected = Endpoint(
 3306   3250   
            uri = Url.parse("http://localhost:8000"),
 3307   3251   
            attributes = attributesOf {
 3308   3252   
                SigningContextAttributeKey to listOf(
 3309   3253   
                    sigV4(
 3310   3254   
                        serviceName = "dynamodb",
 3311   3255   
                        disableDoubleUriEncode = false,
 3312   3256   
                        signingRegion = "us-east-1",
 3313   3257   
                    ),
 3314   3258   
                )
 3315   3259   
            },
 3316   3260   
        )
 3317   3261   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3318   3262   
        expectEqualEndpoints(expected, actual)
 3319   3263   
    }
 3320   3264   
 3321   3265   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
 3322   3266   
    @Test
 3323         -
    fun test179() = runTest {
        3267  +
    fun test175() = runTest {
 3324   3268   
        val params = DynamoDbEndpointParameters {
 3325   3269   
            useFips = false
 3326   3270   
            useDualStack = false
 3327   3271   
            accountId = "111111111111"
 3328   3272   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3329   3273   
            accountIdEndpointMode = "required"
 3330   3274   
            region = "local"
 3331   3275   
        }
 3332   3276   
        val expected = Endpoint(
 3333   3277   
            uri = Url.parse("http://localhost:8000"),
 3334   3278   
            attributes = attributesOf {
 3335   3279   
                SigningContextAttributeKey to listOf(
 3336   3280   
                    sigV4(
 3337   3281   
                        serviceName = "dynamodb",
 3338   3282   
                        disableDoubleUriEncode = false,
 3339   3283   
                        signingRegion = "us-east-1",
 3340   3284   
                    ),
 3341   3285   
                )
 3342   3286   
            },
 3343   3287   
        )
 3344   3288   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3345   3289   
        expectEqualEndpoints(expected, actual)
 3346   3290   
    }
 3347   3291   
 3348   3292   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
 3349   3293   
    @Test
 3350         -
    fun test180() = runTest {
        3294  +
    fun test176() = runTest {
 3351   3295   
        val params = DynamoDbEndpointParameters {
 3352   3296   
            useFips = false
 3353   3297   
            useDualStack = false
 3354   3298   
            accountId = "111111111111"
 3355   3299   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 3356   3300   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3357   3301   
            accountIdEndpointMode = "required"
 3358   3302   
            region = "local"
 3359   3303   
        }
 3360   3304   
        val expected = Endpoint(
 3361   3305   
            uri = Url.parse("http://localhost:8000"),
 3362   3306   
            attributes = attributesOf {
 3363   3307   
                SigningContextAttributeKey to listOf(
 3364   3308   
                    sigV4(
 3365   3309   
                        serviceName = "dynamodb",
 3366   3310   
                        disableDoubleUriEncode = false,
 3367   3311   
                        signingRegion = "us-east-1",
 3368   3312   
                    ),
 3369   3313   
                )
 3370   3314   
            },
 3371   3315   
        )
 3372   3316   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3373   3317   
        expectEqualEndpoints(expected, actual)
 3374   3318   
    }
 3375   3319   
 3376   3320   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
 3377   3321   
    @Test
 3378         -
    fun test181() = runTest {
        3322  +
    fun test177() = runTest {
 3379   3323   
        val params = DynamoDbEndpointParameters {
 3380   3324   
            useFips = false
 3381   3325   
            useDualStack = false
 3382   3326   
            accountId = "111111111111"
 3383   3327   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 3384   3328   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3385   3329   
            accountIdEndpointMode = "required"
 3386   3330   
            region = "local"
 3387   3331   
        }
 3388   3332   
        val expected = Endpoint(
 3389   3333   
            uri = Url.parse("http://localhost:8000"),
 3390   3334   
            attributes = attributesOf {
 3391   3335   
                SigningContextAttributeKey to listOf(
 3392   3336   
                    sigV4(
 3393   3337   
                        serviceName = "dynamodb",
 3394   3338   
                        disableDoubleUriEncode = false,
 3395   3339   
                        signingRegion = "us-east-1",
 3396   3340   
                    ),
 3397   3341   
                )
 3398   3342   
            },
 3399   3343   
        )
 3400   3344   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3401   3345   
        expectEqualEndpoints(expected, actual)
 3402   3346   
    }
 3403   3347   
 3404   3348   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
 3405   3349   
    @Test
 3406         -
    fun test182() = runTest {
        3350  +
    fun test178() = runTest {
 3407   3351   
        val params = DynamoDbEndpointParameters {
 3408   3352   
            useFips = false
 3409   3353   
            useDualStack = false
 3410   3354   
            accountId = "111111111111"
 3411   3355   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 3412   3356   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3413   3357   
            accountIdEndpointMode = "required"
 3414   3358   
            region = "local"
 3415   3359   
        }
 3416   3360   
        val expected = Endpoint(
 3417   3361   
            uri = Url.parse("http://localhost:8000"),
 3418   3362   
            attributes = attributesOf {
 3419   3363   
                SigningContextAttributeKey to listOf(
 3420   3364   
                    sigV4(
 3421   3365   
                        serviceName = "dynamodb",
 3422   3366   
                        disableDoubleUriEncode = false,
 3423   3367   
                        signingRegion = "us-east-1",
 3424   3368   
                    ),
 3425   3369   
                )
 3426   3370   
            },
 3427   3371   
        )
 3428   3372   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3429   3373   
        expectEqualEndpoints(expected, actual)
 3430   3374   
    }
 3431   3375   
 3432   3376   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
 3433   3377   
    @Test
 3434         -
    fun test183() = runTest {
        3378  +
    fun test179() = runTest {
 3435   3379   
        val params = DynamoDbEndpointParameters {
 3436   3380   
            useFips = false
 3437   3381   
            useDualStack = false
 3438   3382   
            accountId = "111111111111"
 3439   3383   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 3440   3384   
            resourceArnList = listOf("arn:aws:dynamodb:us-west-2:333333333333:table/table_name")
 3441   3385   
            accountIdEndpointMode = "required"
 3442   3386   
            region = "local"
 3443   3387   
        }
 3444   3388   
        val expected = Endpoint(
 3445   3389   
            uri = Url.parse("http://localhost:8000"),
 3446   3390   
            attributes = attributesOf {
 3447   3391   
                SigningContextAttributeKey to listOf(
 3448   3392   
                    sigV4(
 3449   3393   
                        serviceName = "dynamodb",
 3450   3394   
                        disableDoubleUriEncode = false,
 3451   3395   
                        signingRegion = "us-east-1",
 3452   3396   
                    ),
 3453   3397   
                )
 3454   3398   
            },
 3455   3399   
        )
 3456   3400   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3457   3401   
        expectEqualEndpoints(expected, actual)
 3458   3402   
    }
 3459   3403   
 3460   3404   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=required, Region=local}
 3461   3405   
    @Test
 3462         -
    fun test184() = runTest {
        3406  +
    fun test180() = runTest {
 3463   3407   
        val params = DynamoDbEndpointParameters {
 3464   3408   
            useFips = false
 3465   3409   
            useDualStack = false
 3466   3410   
            accountId = "111111111111"
 3467   3411   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 3468   3412   
            resourceArnList = listOf("arn:aws:s3:us-east-1:333333333333:stream/testStream")
 3469   3413   
            accountIdEndpointMode = "required"
 3470   3414   
            region = "local"
 3471   3415   
        }
 3472   3416   
        val expected = Endpoint(
 3473   3417   
            uri = Url.parse("http://localhost:8000"),
 3474   3418   
            attributes = attributesOf {
 3475   3419   
                SigningContextAttributeKey to listOf(
 3476   3420   
                    sigV4(
 3477   3421   
                        serviceName = "dynamodb",
 3478   3422   
                        disableDoubleUriEncode = false,
 3479   3423   
                        signingRegion = "us-east-1",
 3480   3424   
                    ),
 3481   3425   
                )
 3482   3426   
            },
 3483   3427   
        )
 3484   3428   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3485   3429   
        expectEqualEndpoints(expected, actual)
 3486   3430   
    }
 3487   3431   
 3488   3432   
    // {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=required, Region=local}
 3489   3433   
    @Test
 3490         -
    fun test185() = runTest {
        3434  +
    fun test181() = runTest {
 3491   3435   
        val params = DynamoDbEndpointParameters {
 3492   3436   
            useFips = false
 3493   3437   
            useDualStack = false
 3494   3438   
            accountId = ""
 3495   3439   
            accountIdEndpointMode = "required"
 3496   3440   
            region = "local"
 3497   3441   
        }
 3498   3442   
        val expected = Endpoint(
 3499   3443   
            uri = Url.parse("http://localhost:8000"),
 3500   3444   
            attributes = attributesOf {
 3501   3445   
                SigningContextAttributeKey to listOf(
 3502   3446   
                    sigV4(
 3503   3447   
                        serviceName = "dynamodb",
 3504   3448   
                        disableDoubleUriEncode = false,
 3505   3449   
                        signingRegion = "us-east-1",
 3506   3450   
                    ),
 3507   3451   
                )
 3508   3452   
            },
 3509   3453   
        )
 3510   3454   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3511   3455   
        expectEqualEndpoints(expected, actual)
 3512   3456   
    }
 3513   3457   
 3514   3458   
    // {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=local}
 3515   3459   
    @Test
 3516         -
    fun test186() = runTest {
        3460  +
    fun test182() = runTest {
 3517   3461   
        val params = DynamoDbEndpointParameters {
 3518   3462   
            useFips = true
 3519   3463   
            useDualStack = true
 3520   3464   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 3521   3465   
            accountIdEndpointMode = "required"
 3522   3466   
            region = "local"
 3523   3467   
        }
 3524   3468   
        val ex = assertFailsWith<EndpointProviderException> {
 3525   3469   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3526   3470   
        }
 3527   3471   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 3528   3472   
    }
 3529   3473   
 3530   3474   
    // {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=local}
 3531   3475   
    @Test
 3532         -
    fun test187() = runTest {
        3476  +
    fun test183() = runTest {
 3533   3477   
        val params = DynamoDbEndpointParameters {
 3534   3478   
            useFips = true
 3535   3479   
            useDualStack = false
 3536   3480   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 3537   3481   
            accountIdEndpointMode = "required"
 3538   3482   
            region = "local"
 3539   3483   
        }
 3540   3484   
        val ex = assertFailsWith<EndpointProviderException> {
 3541   3485   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3542   3486   
        }
 3543   3487   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 3544   3488   
    }
 3545   3489   
 3546   3490   
    // {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=local}
 3547   3491   
    @Test
 3548         -
    fun test188() = runTest {
        3492  +
    fun test184() = runTest {
 3549   3493   
        val params = DynamoDbEndpointParameters {
 3550   3494   
            useFips = false
 3551   3495   
            useDualStack = true
 3552   3496   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 3553   3497   
            accountIdEndpointMode = "required"
 3554   3498   
            region = "local"
 3555   3499   
        }
 3556   3500   
        val ex = assertFailsWith<EndpointProviderException> {
 3557   3501   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3558   3502   
        }
 3559   3503   
        assertEquals("Invalid Configuration: Dualstack and local endpoint are not supported", ex.message)
 3560   3504   
    }
 3561   3505   
 3562   3506   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=local}
 3563   3507   
    @Test
 3564         -
    fun test189() = runTest {
        3508  +
    fun test185() = runTest {
 3565   3509   
        val params = DynamoDbEndpointParameters {
 3566   3510   
            useFips = false
 3567   3511   
            useDualStack = false
 3568   3512   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 3569   3513   
            accountIdEndpointMode = "required"
 3570   3514   
            region = "local"
 3571   3515   
        }
 3572   3516   
        val expected = Endpoint(
 3573   3517   
            uri = Url.parse("http://localhost:8000"),
 3574   3518   
            attributes = attributesOf {
 3575   3519   
                SigningContextAttributeKey to listOf(
 3576   3520   
                    sigV4(
 3577   3521   
                        serviceName = "dynamodb",
 3578   3522   
                        disableDoubleUriEncode = false,
 3579   3523   
                        signingRegion = "us-east-1",
 3580   3524   
                    ),
 3581   3525   
                )
 3582   3526   
            },
 3583   3527   
        )
 3584   3528   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3585   3529   
        expectEqualEndpoints(expected, actual)
 3586   3530   
    }
 3587   3531   
 3588   3532   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=required, Region=local}
 3589   3533   
    @Test
 3590         -
    fun test190() = runTest {
        3534  +
    fun test186() = runTest {
 3591   3535   
        val params = DynamoDbEndpointParameters {
 3592   3536   
            useFips = false
 3593   3537   
            useDualStack = false
 3594   3538   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 3595   3539   
            accountIdEndpointMode = "required"
 3596   3540   
            region = "local"
 3597   3541   
        }
 3598   3542   
        val expected = Endpoint(
 3599   3543   
            uri = Url.parse("http://localhost:8000"),
 3600   3544   
            attributes = attributesOf {
 3601   3545   
                SigningContextAttributeKey to listOf(
 3602   3546   
                    sigV4(
 3603   3547   
                        serviceName = "dynamodb",
 3604   3548   
                        disableDoubleUriEncode = false,
 3605   3549   
                        signingRegion = "us-east-1",
 3606   3550   
                    ),
 3607   3551   
                )
 3608   3552   
            },
 3609   3553   
        )
 3610   3554   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3611   3555   
        expectEqualEndpoints(expected, actual)
 3612   3556   
    }
 3613   3557   
 3614   3558   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=required, Region=local}
 3615   3559   
    @Test
 3616         -
    fun test191() = runTest {
        3560  +
    fun test187() = runTest {
 3617   3561   
        val params = DynamoDbEndpointParameters {
 3618   3562   
            useFips = false
 3619   3563   
            useDualStack = false
 3620   3564   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 3621   3565   
            accountIdEndpointMode = "required"
 3622   3566   
            region = "local"
 3623   3567   
        }
 3624   3568   
        val expected = Endpoint(
 3625   3569   
            uri = Url.parse("http://localhost:8000"),
 3626   3570   
            attributes = attributesOf {
 3627   3571   
                SigningContextAttributeKey to listOf(
 3628   3572   
                    sigV4(
 3629   3573   
                        serviceName = "dynamodb",
 3630   3574   
                        disableDoubleUriEncode = false,
 3631   3575   
                        signingRegion = "us-east-1",
 3632   3576   
                    ),
 3633   3577   
                )
 3634   3578   
            },
 3635   3579   
        )
 3636   3580   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3637   3581   
        expectEqualEndpoints(expected, actual)
 3638   3582   
    }
 3639   3583   
 3640   3584   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=required, Region=local}
 3641   3585   
    @Test
 3642         -
    fun test192() = runTest {
        3586  +
    fun test188() = runTest {
 3643   3587   
        val params = DynamoDbEndpointParameters {
 3644   3588   
            useFips = false
 3645   3589   
            useDualStack = false
 3646   3590   
            resourceArn = ""
 3647   3591   
            accountIdEndpointMode = "required"
 3648   3592   
            region = "local"
 3649   3593   
        }
 3650   3594   
        val expected = Endpoint(
 3651   3595   
            uri = Url.parse("http://localhost:8000"),
 3652   3596   
            attributes = attributesOf {
 3653   3597   
                SigningContextAttributeKey to listOf(
 3654   3598   
                    sigV4(
 3655   3599   
                        serviceName = "dynamodb",
 3656   3600   
                        disableDoubleUriEncode = false,
 3657   3601   
                        signingRegion = "us-east-1",
 3658   3602   
                    ),
 3659   3603   
                )
 3660   3604   
            },
 3661   3605   
        )
 3662   3606   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3663   3607   
        expectEqualEndpoints(expected, actual)
 3664   3608   
    }
 3665   3609   
 3666   3610   
    // {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
 3667   3611   
    @Test
 3668         -
    fun test193() = runTest {
        3612  +
    fun test189() = runTest {
 3669   3613   
        val params = DynamoDbEndpointParameters {
 3670   3614   
            useFips = true
 3671   3615   
            useDualStack = true
 3672   3616   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3673   3617   
            accountIdEndpointMode = "required"
 3674   3618   
            region = "local"
 3675   3619   
        }
 3676   3620   
        val ex = assertFailsWith<EndpointProviderException> {
 3677   3621   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3678   3622   
        }
 3679   3623   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 3680   3624   
    }
 3681   3625   
 3682   3626   
    // {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
 3683   3627   
    @Test
 3684         -
    fun test194() = runTest {
        3628  +
    fun test190() = runTest {
 3685   3629   
        val params = DynamoDbEndpointParameters {
 3686   3630   
            useFips = true
 3687   3631   
            useDualStack = false
 3688   3632   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3689   3633   
            accountIdEndpointMode = "required"
 3690   3634   
            region = "local"
 3691   3635   
        }
 3692   3636   
        val ex = assertFailsWith<EndpointProviderException> {
 3693   3637   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3694   3638   
        }
 3695   3639   
        assertEquals("Invalid Configuration: FIPS and local endpoint are not supported", ex.message)
 3696   3640   
    }
 3697   3641   
 3698   3642   
    // {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
 3699   3643   
    @Test
 3700         -
    fun test195() = runTest {
        3644  +
    fun test191() = runTest {
 3701   3645   
        val params = DynamoDbEndpointParameters {
 3702   3646   
            useFips = false
 3703   3647   
            useDualStack = true
 3704   3648   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3705   3649   
            accountIdEndpointMode = "required"
 3706   3650   
            region = "local"
 3707   3651   
        }
 3708   3652   
        val ex = assertFailsWith<EndpointProviderException> {
 3709   3653   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3710   3654   
        }
 3711   3655   
        assertEquals("Invalid Configuration: Dualstack and local endpoint are not supported", ex.message)
 3712   3656   
    }
 3713   3657   
 3714   3658   
    // {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
 3715   3659   
    @Test
 3716         -
    fun test196() = runTest {
        3660  +
    fun test192() = runTest {
 3717   3661   
        val params = DynamoDbEndpointParameters {
 3718   3662   
            useFips = false
 3719   3663   
            useDualStack = false
 3720   3664   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3721   3665   
            accountIdEndpointMode = "required"
 3722   3666   
            region = "local"
 3723   3667   
        }
 3724   3668   
        val expected = Endpoint(
 3725   3669   
            uri = Url.parse("http://localhost:8000"),
 3726   3670   
            attributes = attributesOf {
 3727   3671   
                SigningContextAttributeKey to listOf(
 3728   3672   
                    sigV4(
 3729   3673   
                        serviceName = "dynamodb",
 3730   3674   
                        disableDoubleUriEncode = false,
 3731   3675   
                        signingRegion = "us-east-1",
 3732   3676   
                    ),
 3733   3677   
                )
 3734   3678   
            },
 3735   3679   
        )
 3736   3680   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3737   3681   
        expectEqualEndpoints(expected, actual)
 3738   3682   
    }
 3739   3683   
 3740   3684   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=local}
 3741   3685   
    @Test
 3742         -
    fun test197() = runTest {
        3686  +
    fun test193() = runTest {
 3743   3687   
        val params = DynamoDbEndpointParameters {
 3744   3688   
            useFips = false
 3745   3689   
            useDualStack = false
 3746   3690   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 3747   3691   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3748   3692   
            accountIdEndpointMode = "required"
 3749   3693   
            region = "local"
 3750   3694   
        }
 3751   3695   
        val expected = Endpoint(
 3752   3696   
            uri = Url.parse("http://localhost:8000"),
 3753   3697   
            attributes = attributesOf {
 3754   3698   
                SigningContextAttributeKey to listOf(
 3755   3699   
                    sigV4(
 3756   3700   
                        serviceName = "dynamodb",
 3757   3701   
                        disableDoubleUriEncode = false,
 3758   3702   
                        signingRegion = "us-east-1",
 3759   3703   
                    ),
 3760   3704   
                )
 3761   3705   
            },
 3762   3706   
        )
 3763   3707   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3764   3708   
        expectEqualEndpoints(expected, actual)
 3765   3709   
    }
 3766   3710   
 3767   3711   
    // {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=required, Region=local}
 3768   3712   
    @Test
 3769         -
    fun test198() = runTest {
        3713  +
    fun test194() = runTest {
 3770   3714   
        val params = DynamoDbEndpointParameters {
 3771   3715   
            useFips = false
 3772   3716   
            useDualStack = false
 3773   3717   
            accountIdEndpointMode = "required"
 3774   3718   
            region = "local"
 3775   3719   
        }
 3776   3720   
        val expected = Endpoint(
 3777   3721   
            uri = Url.parse("http://localhost:8000"),
 3778   3722   
            attributes = attributesOf {
 3779   3723   
                SigningContextAttributeKey to listOf(
 3780   3724   
                    sigV4(
 3781   3725   
                        serviceName = "dynamodb",
 3782   3726   
                        disableDoubleUriEncode = false,
 3783   3727   
                        signingRegion = "us-east-1",
 3784   3728   
                    ),
 3785   3729   
                )
 3786   3730   
            },
 3787   3731   
        )
 3788   3732   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3789   3733   
        expectEqualEndpoints(expected, actual)
 3790   3734   
    }
 3791   3735   
 3792   3736   
    // {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-east-1}
 3793   3737   
    @Test
 3794         -
    fun test199() = runTest {
        3738  +
    fun test195() = runTest {
 3795   3739   
        val params = DynamoDbEndpointParameters {
 3796   3740   
            useFips = true
 3797   3741   
            useDualStack = true
 3798   3742   
            accountId = "111111111111"
 3799   3743   
            accountIdEndpointMode = "preferred"
 3800   3744   
            region = "us-east-1"
 3801   3745   
        }
 3802   3746   
        val expected = Endpoint(
 3803   3747   
            uri = Url.parse("https://dynamodb-fips.us-east-1.api.aws"),
 3804   3748   
        )
 3805   3749   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3806   3750   
        expectEqualEndpoints(expected, actual)
 3807   3751   
    }
 3808   3752   
 3809   3753   
    // {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-east-1}
 3810   3754   
    @Test
 3811         -
    fun test200() = runTest {
        3755  +
    fun test196() = runTest {
 3812   3756   
        val params = DynamoDbEndpointParameters {
 3813   3757   
            useFips = true
 3814   3758   
            useDualStack = false
 3815   3759   
            accountId = "111111111111"
 3816   3760   
            accountIdEndpointMode = "preferred"
 3817   3761   
            region = "us-east-1"
 3818   3762   
        }
 3819   3763   
        val expected = Endpoint(
 3820   3764   
            uri = Url.parse("https://dynamodb-fips.us-east-1.amazonaws.com"),
 3821   3765   
        )
 3822   3766   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3823   3767   
        expectEqualEndpoints(expected, actual)
 3824   3768   
    }
 3825   3769   
 3826   3770   
    // {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-east-1}
 3827   3771   
    @Test
 3828         -
    fun test201() = runTest {
        3772  +
    fun test197() = runTest {
 3829   3773   
        val params = DynamoDbEndpointParameters {
 3830   3774   
            useFips = false
 3831   3775   
            useDualStack = true
 3832   3776   
            accountId = "111111111111"
 3833   3777   
            accountIdEndpointMode = "preferred"
 3834   3778   
            region = "us-east-1"
 3835   3779   
        }
 3836   3780   
        val expected = Endpoint(
 3837   3781   
            uri = Url.parse("https://dynamodb.us-east-1.api.aws"),
 3838   3782   
        )
 3839   3783   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3840   3784   
        expectEqualEndpoints(expected, actual)
 3841   3785   
    }
 3842   3786   
 3843   3787   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-east-1}
 3844   3788   
    @Test
 3845         -
    fun test202() = runTest {
        3789  +
    fun test198() = runTest {
 3846   3790   
        val params = DynamoDbEndpointParameters {
 3847   3791   
            useFips = false
 3848   3792   
            useDualStack = false
 3849   3793   
            accountId = "111111111111"
 3850   3794   
            accountIdEndpointMode = "preferred"
 3851   3795   
            region = "us-east-1"
 3852   3796   
        }
 3853   3797   
        val expected = Endpoint(
 3854   3798   
            uri = Url.parse("https://111111111111.ddb.us-east-1.amazonaws.com"),
 3855   3799   
        )
 3856   3800   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3857   3801   
        expectEqualEndpoints(expected, actual)
 3858   3802   
    }
 3859   3803   
 3860   3804   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
 3861   3805   
    @Test
 3862         -
    fun test203() = runTest {
        3806  +
    fun test199() = runTest {
 3863   3807   
        val params = DynamoDbEndpointParameters {
 3864   3808   
            useFips = false
 3865   3809   
            useDualStack = false
 3866   3810   
            accountId = "111111111111"
 3867   3811   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3868   3812   
            accountIdEndpointMode = "preferred"
 3869   3813   
            region = "us-east-1"
 3870   3814   
        }
 3871   3815   
        val expected = Endpoint(
 3872   3816   
            uri = Url.parse("https://333333333333.ddb.us-east-1.amazonaws.com"),
 3873   3817   
        )
 3874   3818   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3875   3819   
        expectEqualEndpoints(expected, actual)
 3876   3820   
    }
 3877   3821   
 3878   3822   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
 3879   3823   
    @Test
 3880         -
    fun test204() = runTest {
        3824  +
    fun test200() = runTest {
 3881   3825   
        val params = DynamoDbEndpointParameters {
 3882   3826   
            useFips = false
 3883   3827   
            useDualStack = false
 3884   3828   
            accountId = "111111111111"
 3885   3829   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 3886   3830   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3887   3831   
            accountIdEndpointMode = "preferred"
 3888   3832   
            region = "us-east-1"
 3889   3833   
        }
 3890   3834   
        val expected = Endpoint(
 3891   3835   
            uri = Url.parse("https://222222222222.ddb.us-east-1.amazonaws.com"),
 3892   3836   
        )
 3893   3837   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3894   3838   
        expectEqualEndpoints(expected, actual)
 3895   3839   
    }
 3896   3840   
 3897   3841   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
 3898   3842   
    @Test
 3899         -
    fun test205() = runTest {
        3843  +
    fun test201() = runTest {
 3900   3844   
        val params = DynamoDbEndpointParameters {
 3901   3845   
            useFips = false
 3902   3846   
            useDualStack = false
 3903   3847   
            accountId = "111111111111"
 3904   3848   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 3905   3849   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3906   3850   
            accountIdEndpointMode = "preferred"
 3907   3851   
            region = "us-east-1"
 3908   3852   
        }
 3909   3853   
        val expected = Endpoint(
 3910   3854   
            uri = Url.parse("https://333333333333.ddb.us-east-1.amazonaws.com"),
 3911   3855   
        )
 3912   3856   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3913   3857   
        expectEqualEndpoints(expected, actual)
 3914   3858   
    }
 3915   3859   
 3916   3860   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
 3917   3861   
    @Test
 3918         -
    fun test206() = runTest {
        3862  +
    fun test202() = runTest {
 3919   3863   
        val params = DynamoDbEndpointParameters {
 3920   3864   
            useFips = false
 3921   3865   
            useDualStack = false
 3922   3866   
            accountId = "111111111111"
 3923   3867   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 3924   3868   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 3925   3869   
            accountIdEndpointMode = "preferred"
 3926   3870   
            region = "us-east-1"
 3927   3871   
        }
 3928   3872   
        val expected = Endpoint(
 3929   3873   
            uri = Url.parse("https://333333333333.ddb.us-east-1.amazonaws.com"),
 3930   3874   
        )
 3931   3875   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3932   3876   
        expectEqualEndpoints(expected, actual)
 3933   3877   
    }
 3934   3878   
 3935   3879   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
 3936   3880   
    @Test
 3937         -
    fun test207() = runTest {
        3881  +
    fun test203() = runTest {
 3938   3882   
        val params = DynamoDbEndpointParameters {
 3939   3883   
            useFips = false
 3940   3884   
            useDualStack = false
 3941   3885   
            accountId = "111111111111"
 3942   3886   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 3943   3887   
            resourceArnList = listOf("arn:aws:dynamodb:us-west-2:333333333333:table/table_name")
 3944   3888   
            accountIdEndpointMode = "preferred"
 3945   3889   
            region = "us-east-1"
 3946   3890   
        }
 3947   3891   
        val expected = Endpoint(
 3948   3892   
            uri = Url.parse("https://111111111111.ddb.us-east-1.amazonaws.com"),
 3949   3893   
        )
 3950   3894   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3951   3895   
        expectEqualEndpoints(expected, actual)
 3952   3896   
    }
 3953   3897   
 3954   3898   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=preferred, Region=us-east-1}
 3955   3899   
    @Test
 3956         -
    fun test208() = runTest {
        3900  +
    fun test204() = runTest {
 3957   3901   
        val params = DynamoDbEndpointParameters {
 3958   3902   
            useFips = false
 3959   3903   
            useDualStack = false
 3960   3904   
            accountId = "111111111111"
 3961   3905   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 3962   3906   
            resourceArnList = listOf("arn:aws:s3:us-east-1:333333333333:stream/testStream")
 3963   3907   
            accountIdEndpointMode = "preferred"
 3964   3908   
            region = "us-east-1"
 3965   3909   
        }
 3966   3910   
        val expected = Endpoint(
 3967   3911   
            uri = Url.parse("https://111111111111.ddb.us-east-1.amazonaws.com"),
 3968   3912   
        )
 3969   3913   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3970   3914   
        expectEqualEndpoints(expected, actual)
 3971   3915   
    }
 3972   3916   
 3973   3917   
    // {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=preferred, Region=us-east-1}
 3974   3918   
    @Test
 3975         -
    fun test209() = runTest {
        3919  +
    fun test205() = runTest {
 3976   3920   
        val params = DynamoDbEndpointParameters {
 3977   3921   
            useFips = false
 3978   3922   
            useDualStack = false
 3979   3923   
            accountId = ""
 3980   3924   
            accountIdEndpointMode = "preferred"
 3981   3925   
            region = "us-east-1"
 3982   3926   
        }
 3983   3927   
        val ex = assertFailsWith<EndpointProviderException> {
 3984   3928   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 3985   3929   
        }
 3986   3930   
        assertEquals("Credentials-sourced account ID parameter is invalid", ex.message)
 3987   3931   
    }
 3988   3932   
 3989   3933   
    // {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-east-1}
 3990   3934   
    @Test
 3991         -
    fun test210() = runTest {
        3935  +
    fun test206() = runTest {
 3992   3936   
        val params = DynamoDbEndpointParameters {
 3993   3937   
            useFips = true
 3994   3938   
            useDualStack = true
 3995   3939   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 3996   3940   
            accountIdEndpointMode = "preferred"
 3997   3941   
            region = "us-east-1"
 3998   3942   
        }
 3999   3943   
        val expected = Endpoint(
 4000   3944   
            uri = Url.parse("https://dynamodb-fips.us-east-1.api.aws"),
 4001   3945   
        )
 4002   3946   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4003   3947   
        expectEqualEndpoints(expected, actual)
 4004   3948   
    }
 4005   3949   
 4006   3950   
    // {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-east-1}
 4007   3951   
    @Test
 4008         -
    fun test211() = runTest {
        3952  +
    fun test207() = runTest {
 4009   3953   
        val params = DynamoDbEndpointParameters {
 4010   3954   
            useFips = true
 4011   3955   
            useDualStack = false
 4012   3956   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4013   3957   
            accountIdEndpointMode = "preferred"
 4014   3958   
            region = "us-east-1"
 4015   3959   
        }
 4016   3960   
        val expected = Endpoint(
 4017   3961   
            uri = Url.parse("https://dynamodb-fips.us-east-1.amazonaws.com"),
 4018   3962   
        )
 4019   3963   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4020   3964   
        expectEqualEndpoints(expected, actual)
 4021   3965   
    }
 4022   3966   
 4023   3967   
    // {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-east-1}
 4024   3968   
    @Test
 4025         -
    fun test212() = runTest {
        3969  +
    fun test208() = runTest {
 4026   3970   
        val params = DynamoDbEndpointParameters {
 4027   3971   
            useFips = false
 4028   3972   
            useDualStack = true
 4029   3973   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4030   3974   
            accountIdEndpointMode = "preferred"
 4031   3975   
            region = "us-east-1"
 4032   3976   
        }
 4033   3977   
        val expected = Endpoint(
 4034   3978   
            uri = Url.parse("https://dynamodb.us-east-1.api.aws"),
 4035   3979   
        )
 4036   3980   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4037   3981   
        expectEqualEndpoints(expected, actual)
 4038   3982   
    }
 4039   3983   
 4040   3984   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-east-1}
 4041   3985   
    @Test
 4042         -
    fun test213() = runTest {
        3986  +
    fun test209() = runTest {
 4043   3987   
        val params = DynamoDbEndpointParameters {
 4044   3988   
            useFips = false
 4045   3989   
            useDualStack = false
 4046   3990   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4047   3991   
            accountIdEndpointMode = "preferred"
 4048   3992   
            region = "us-east-1"
 4049   3993   
        }
 4050   3994   
        val expected = Endpoint(
 4051   3995   
            uri = Url.parse("https://222222222222.ddb.us-east-1.amazonaws.com"),
 4052   3996   
        )
 4053   3997   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4054   3998   
        expectEqualEndpoints(expected, actual)
 4055   3999   
    }
 4056   4000   
 4057   4001   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-east-1}
 4058   4002   
    @Test
 4059         -
    fun test214() = runTest {
        4003  +
    fun test210() = runTest {
 4060   4004   
        val params = DynamoDbEndpointParameters {
 4061   4005   
            useFips = false
 4062   4006   
            useDualStack = false
 4063   4007   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 4064   4008   
            accountIdEndpointMode = "preferred"
 4065   4009   
            region = "us-east-1"
 4066   4010   
        }
 4067   4011   
        val expected = Endpoint(
 4068   4012   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 4069   4013   
        )
 4070   4014   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4071   4015   
        expectEqualEndpoints(expected, actual)
 4072   4016   
    }
 4073   4017   
 4074   4018   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=preferred, Region=us-east-1}
 4075   4019   
    @Test
 4076         -
    fun test215() = runTest {
        4020  +
    fun test211() = runTest {
 4077   4021   
        val params = DynamoDbEndpointParameters {
 4078   4022   
            useFips = false
 4079   4023   
            useDualStack = false
 4080   4024   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 4081   4025   
            accountIdEndpointMode = "preferred"
 4082   4026   
            region = "us-east-1"
 4083   4027   
        }
 4084   4028   
        val expected = Endpoint(
 4085   4029   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 4086   4030   
        )
 4087   4031   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4088   4032   
        expectEqualEndpoints(expected, actual)
 4089   4033   
    }
 4090   4034   
 4091   4035   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=preferred, Region=us-east-1}
 4092   4036   
    @Test
 4093         -
    fun test216() = runTest {
        4037  +
    fun test212() = runTest {
 4094   4038   
        val params = DynamoDbEndpointParameters {
 4095   4039   
            useFips = false
 4096   4040   
            useDualStack = false
 4097   4041   
            resourceArn = ""
 4098   4042   
            accountIdEndpointMode = "preferred"
 4099   4043   
            region = "us-east-1"
 4100   4044   
        }
 4101   4045   
        val expected = Endpoint(
 4102   4046   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 4103   4047   
        )
 4104   4048   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4105   4049   
        expectEqualEndpoints(expected, actual)
 4106   4050   
    }
 4107   4051   
 4108   4052   
    // {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
 4109   4053   
    @Test
 4110         -
    fun test217() = runTest {
        4054  +
    fun test213() = runTest {
 4111   4055   
        val params = DynamoDbEndpointParameters {
 4112   4056   
            useFips = true
 4113   4057   
            useDualStack = true
 4114   4058   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4115   4059   
            accountIdEndpointMode = "preferred"
 4116   4060   
            region = "us-east-1"
 4117   4061   
        }
 4118   4062   
        val expected = Endpoint(
 4119   4063   
            uri = Url.parse("https://dynamodb-fips.us-east-1.api.aws"),
 4120   4064   
        )
 4121   4065   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4122   4066   
        expectEqualEndpoints(expected, actual)
 4123   4067   
    }
 4124   4068   
 4125   4069   
    // {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
 4126   4070   
    @Test
 4127         -
    fun test218() = runTest {
        4071  +
    fun test214() = runTest {
 4128   4072   
        val params = DynamoDbEndpointParameters {
 4129   4073   
            useFips = true
 4130   4074   
            useDualStack = false
 4131   4075   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4132   4076   
            accountIdEndpointMode = "preferred"
 4133   4077   
            region = "us-east-1"
 4134   4078   
        }
 4135   4079   
        val expected = Endpoint(
 4136   4080   
            uri = Url.parse("https://dynamodb-fips.us-east-1.amazonaws.com"),
 4137   4081   
        )
 4138   4082   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4139   4083   
        expectEqualEndpoints(expected, actual)
 4140   4084   
    }
 4141   4085   
 4142   4086   
    // {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
 4143   4087   
    @Test
 4144         -
    fun test219() = runTest {
        4088  +
    fun test215() = runTest {
 4145   4089   
        val params = DynamoDbEndpointParameters {
 4146   4090   
            useFips = false
 4147   4091   
            useDualStack = true
 4148   4092   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4149   4093   
            accountIdEndpointMode = "preferred"
 4150   4094   
            region = "us-east-1"
 4151   4095   
        }
 4152   4096   
        val expected = Endpoint(
 4153   4097   
            uri = Url.parse("https://dynamodb.us-east-1.api.aws"),
 4154   4098   
        )
 4155   4099   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4156   4100   
        expectEqualEndpoints(expected, actual)
 4157   4101   
    }
 4158   4102   
 4159   4103   
    // {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
 4160   4104   
    @Test
 4161         -
    fun test220() = runTest {
        4105  +
    fun test216() = runTest {
 4162   4106   
        val params = DynamoDbEndpointParameters {
 4163   4107   
            useFips = false
 4164   4108   
            useDualStack = false
 4165   4109   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4166   4110   
            accountIdEndpointMode = "preferred"
 4167   4111   
            region = "us-east-1"
 4168   4112   
        }
 4169   4113   
        val expected = Endpoint(
 4170   4114   
            uri = Url.parse("https://333333333333.ddb.us-east-1.amazonaws.com"),
 4171   4115   
        )
 4172   4116   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4173   4117   
        expectEqualEndpoints(expected, actual)
 4174   4118   
    }
 4175   4119   
 4176   4120   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-east-1}
 4177   4121   
    @Test
 4178         -
    fun test221() = runTest {
        4122  +
    fun test217() = runTest {
 4179   4123   
        val params = DynamoDbEndpointParameters {
 4180   4124   
            useFips = false
 4181   4125   
            useDualStack = false
 4182   4126   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4183   4127   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4184   4128   
            accountIdEndpointMode = "preferred"
 4185   4129   
            region = "us-east-1"
 4186   4130   
        }
 4187   4131   
        val expected = Endpoint(
 4188   4132   
            uri = Url.parse("https://222222222222.ddb.us-east-1.amazonaws.com"),
 4189   4133   
        )
 4190   4134   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4191   4135   
        expectEqualEndpoints(expected, actual)
 4192   4136   
    }
 4193   4137   
 4194   4138   
    // {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=preferred, Region=us-east-1}
 4195   4139   
    @Test
 4196         -
    fun test222() = runTest {
        4140  +
    fun test218() = runTest {
 4197   4141   
        val params = DynamoDbEndpointParameters {
 4198   4142   
            useFips = false
 4199   4143   
            useDualStack = false
 4200   4144   
            accountIdEndpointMode = "preferred"
 4201   4145   
            region = "us-east-1"
 4202   4146   
        }
 4203   4147   
        val expected = Endpoint(
 4204   4148   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 4205   4149   
        )
 4206   4150   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4207   4151   
        expectEqualEndpoints(expected, actual)
 4208   4152   
    }
 4209   4153   
 4210   4154   
    // {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=us-east-1}
 4211   4155   
    @Test
 4212         -
    fun test223() = runTest {
        4156  +
    fun test219() = runTest {
 4213   4157   
        val params = DynamoDbEndpointParameters {
 4214   4158   
            useFips = true
 4215   4159   
            useDualStack = true
 4216   4160   
            accountId = "111111111111"
 4217   4161   
            accountIdEndpointMode = "required"
 4218   4162   
            region = "us-east-1"
 4219   4163   
        }
 4220   4164   
        val ex = assertFailsWith<EndpointProviderException> {
 4221   4165   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4222   4166   
        }
 4223   4167   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported", ex.message)
 4224   4168   
    }
 4225   4169   
 4226   4170   
    // {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=us-east-1}
 4227   4171   
    @Test
 4228         -
    fun test224() = runTest {
        4172  +
    fun test220() = runTest {
 4229   4173   
        val params = DynamoDbEndpointParameters {
 4230   4174   
            useFips = true
 4231   4175   
            useDualStack = false
 4232   4176   
            accountId = "111111111111"
 4233   4177   
            accountIdEndpointMode = "required"
 4234   4178   
            region = "us-east-1"
 4235   4179   
        }
 4236   4180   
        val ex = assertFailsWith<EndpointProviderException> {
 4237   4181   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4238   4182   
        }
 4239   4183   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported", ex.message)
 4240   4184   
    }
 4241   4185   
 4242   4186   
    // {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=us-east-1}
 4243   4187   
    @Test
 4244         -
    fun test225() = runTest {
        4188  +
    fun test221() = runTest {
 4245   4189   
        val params = DynamoDbEndpointParameters {
 4246   4190   
            useFips = false
 4247   4191   
            useDualStack = true
 4248   4192   
            accountId = "111111111111"
 4249   4193   
            accountIdEndpointMode = "required"
 4250   4194   
            region = "us-east-1"
 4251   4195   
        }
 4252   4196   
        val ex = assertFailsWith<EndpointProviderException> {
 4253   4197   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4254   4198   
        }
 4255   4199   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported", ex.message)
 4256   4200   
    }
 4257   4201   
 4258   4202   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=us-east-1}
 4259   4203   
    @Test
 4260         -
    fun test226() = runTest {
        4204  +
    fun test222() = runTest {
 4261   4205   
        val params = DynamoDbEndpointParameters {
 4262   4206   
            useFips = false
 4263   4207   
            useDualStack = false
 4264   4208   
            accountId = "111111111111"
 4265   4209   
            accountIdEndpointMode = "required"
 4266   4210   
            region = "us-east-1"
 4267   4211   
        }
 4268   4212   
        val expected = Endpoint(
 4269   4213   
            uri = Url.parse("https://111111111111.ddb.us-east-1.amazonaws.com"),
 4270   4214   
        )
 4271   4215   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4272   4216   
        expectEqualEndpoints(expected, actual)
 4273   4217   
    }
 4274   4218   
 4275   4219   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
 4276   4220   
    @Test
 4277         -
    fun test227() = runTest {
        4221  +
    fun test223() = runTest {
 4278   4222   
        val params = DynamoDbEndpointParameters {
 4279   4223   
            useFips = false
 4280   4224   
            useDualStack = false
 4281   4225   
            accountId = "111111111111"
 4282   4226   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4283   4227   
            accountIdEndpointMode = "required"
 4284   4228   
            region = "us-east-1"
 4285   4229   
        }
 4286   4230   
        val expected = Endpoint(
 4287   4231   
            uri = Url.parse("https://333333333333.ddb.us-east-1.amazonaws.com"),
 4288   4232   
        )
 4289   4233   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4290   4234   
        expectEqualEndpoints(expected, actual)
 4291   4235   
    }
 4292   4236   
 4293   4237   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
 4294   4238   
    @Test
 4295         -
    fun test228() = runTest {
        4239  +
    fun test224() = runTest {
 4296   4240   
        val params = DynamoDbEndpointParameters {
 4297   4241   
            useFips = false
 4298   4242   
            useDualStack = false
 4299   4243   
            accountId = "111111111111"
 4300   4244   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4301   4245   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4302   4246   
            accountIdEndpointMode = "required"
 4303   4247   
            region = "us-east-1"
 4304   4248   
        }
 4305   4249   
        val expected = Endpoint(
 4306   4250   
            uri = Url.parse("https://222222222222.ddb.us-east-1.amazonaws.com"),
 4307   4251   
        )
 4308   4252   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4309   4253   
        expectEqualEndpoints(expected, actual)
 4310   4254   
    }
 4311   4255   
 4312   4256   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
 4313   4257   
    @Test
 4314         -
    fun test229() = runTest {
        4258  +
    fun test225() = runTest {
 4315   4259   
        val params = DynamoDbEndpointParameters {
 4316   4260   
            useFips = false
 4317   4261   
            useDualStack = false
 4318   4262   
            accountId = "111111111111"
 4319   4263   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 4320   4264   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4321   4265   
            accountIdEndpointMode = "required"
 4322   4266   
            region = "us-east-1"
 4323   4267   
        }
 4324   4268   
        val expected = Endpoint(
 4325   4269   
            uri = Url.parse("https://333333333333.ddb.us-east-1.amazonaws.com"),
 4326   4270   
        )
 4327   4271   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4328   4272   
        expectEqualEndpoints(expected, actual)
 4329   4273   
    }
 4330   4274   
 4331   4275   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
 4332   4276   
    @Test
 4333         -
    fun test230() = runTest {
        4277  +
    fun test226() = runTest {
 4334   4278   
        val params = DynamoDbEndpointParameters {
 4335   4279   
            useFips = false
 4336   4280   
            useDualStack = false
 4337   4281   
            accountId = "111111111111"
 4338   4282   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 4339   4283   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4340   4284   
            accountIdEndpointMode = "required"
 4341   4285   
            region = "us-east-1"
 4342   4286   
        }
 4343   4287   
        val expected = Endpoint(
 4344   4288   
            uri = Url.parse("https://333333333333.ddb.us-east-1.amazonaws.com"),
 4345   4289   
        )
 4346   4290   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4347   4291   
        expectEqualEndpoints(expected, actual)
 4348   4292   
    }
 4349   4293   
 4350   4294   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
 4351   4295   
    @Test
 4352         -
    fun test231() = runTest {
        4296  +
    fun test227() = runTest {
 4353   4297   
        val params = DynamoDbEndpointParameters {
 4354   4298   
            useFips = false
 4355   4299   
            useDualStack = false
 4356   4300   
            accountId = "111111111111"
 4357   4301   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 4358   4302   
            resourceArnList = listOf("arn:aws:dynamodb:us-west-2:333333333333:table/table_name")
 4359   4303   
            accountIdEndpointMode = "required"
 4360   4304   
            region = "us-east-1"
 4361   4305   
        }
 4362   4306   
        val expected = Endpoint(
 4363   4307   
            uri = Url.parse("https://111111111111.ddb.us-east-1.amazonaws.com"),
 4364   4308   
        )
 4365   4309   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4366   4310   
        expectEqualEndpoints(expected, actual)
 4367   4311   
    }
 4368   4312   
 4369   4313   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=required, Region=us-east-1}
 4370   4314   
    @Test
 4371         -
    fun test232() = runTest {
        4315  +
    fun test228() = runTest {
 4372   4316   
        val params = DynamoDbEndpointParameters {
 4373   4317   
            useFips = false
 4374   4318   
            useDualStack = false
 4375   4319   
            accountId = "111111111111"
 4376   4320   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 4377   4321   
            resourceArnList = listOf("arn:aws:s3:us-east-1:333333333333:stream/testStream")
 4378   4322   
            accountIdEndpointMode = "required"
 4379   4323   
            region = "us-east-1"
 4380   4324   
        }
 4381   4325   
        val expected = Endpoint(
 4382   4326   
            uri = Url.parse("https://111111111111.ddb.us-east-1.amazonaws.com"),
 4383   4327   
        )
 4384   4328   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4385   4329   
        expectEqualEndpoints(expected, actual)
 4386   4330   
    }
 4387   4331   
 4388   4332   
    // {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=required, Region=us-east-1}
 4389   4333   
    @Test
 4390         -
    fun test233() = runTest {
        4334  +
    fun test229() = runTest {
 4391   4335   
        val params = DynamoDbEndpointParameters {
 4392   4336   
            useFips = false
 4393   4337   
            useDualStack = false
 4394   4338   
            accountId = ""
 4395   4339   
            accountIdEndpointMode = "required"
 4396   4340   
            region = "us-east-1"
 4397   4341   
        }
 4398   4342   
        val ex = assertFailsWith<EndpointProviderException> {
 4399   4343   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4400   4344   
        }
 4401   4345   
        assertEquals("Credentials-sourced account ID parameter is invalid", ex.message)
 4402   4346   
    }
 4403   4347   
 4404   4348   
    // {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1}
 4405   4349   
    @Test
 4406         -
    fun test234() = runTest {
        4350  +
    fun test230() = runTest {
 4407   4351   
        val params = DynamoDbEndpointParameters {
 4408   4352   
            useFips = true
 4409   4353   
            useDualStack = true
 4410   4354   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4411   4355   
            accountIdEndpointMode = "required"
 4412   4356   
            region = "us-east-1"
 4413   4357   
        }
 4414   4358   
        val ex = assertFailsWith<EndpointProviderException> {
 4415   4359   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4416   4360   
        }
 4417   4361   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported", ex.message)
 4418   4362   
    }
 4419   4363   
 4420   4364   
    // {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1}
 4421   4365   
    @Test
 4422         -
    fun test235() = runTest {
        4366  +
    fun test231() = runTest {
 4423   4367   
        val params = DynamoDbEndpointParameters {
 4424   4368   
            useFips = true
 4425   4369   
            useDualStack = false
 4426   4370   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4427   4371   
            accountIdEndpointMode = "required"
 4428   4372   
            region = "us-east-1"
 4429   4373   
        }
 4430   4374   
        val ex = assertFailsWith<EndpointProviderException> {
 4431   4375   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4432   4376   
        }
 4433   4377   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported", ex.message)
 4434   4378   
    }
 4435   4379   
 4436   4380   
    // {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1}
 4437   4381   
    @Test
 4438         -
    fun test236() = runTest {
        4382  +
    fun test232() = runTest {
 4439   4383   
        val params = DynamoDbEndpointParameters {
 4440   4384   
            useFips = false
 4441   4385   
            useDualStack = true
 4442   4386   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4443   4387   
            accountIdEndpointMode = "required"
 4444   4388   
            region = "us-east-1"
 4445   4389   
        }
 4446   4390   
        val ex = assertFailsWith<EndpointProviderException> {
 4447   4391   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4448   4392   
        }
 4449   4393   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported", ex.message)
 4450   4394   
    }
 4451   4395   
 4452   4396   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1}
 4453   4397   
    @Test
 4454         -
    fun test237() = runTest {
        4398  +
    fun test233() = runTest {
 4455   4399   
        val params = DynamoDbEndpointParameters {
 4456   4400   
            useFips = false
 4457   4401   
            useDualStack = false
 4458   4402   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4459   4403   
            accountIdEndpointMode = "required"
 4460   4404   
            region = "us-east-1"
 4461   4405   
        }
 4462   4406   
        val expected = Endpoint(
 4463   4407   
            uri = Url.parse("https://222222222222.ddb.us-east-1.amazonaws.com"),
 4464   4408   
        )
 4465   4409   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4466   4410   
        expectEqualEndpoints(expected, actual)
 4467   4411   
    }
 4468   4412   
 4469   4413   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=required, Region=us-east-1}
 4470   4414   
    @Test
 4471         -
    fun test238() = runTest {
        4415  +
    fun test234() = runTest {
 4472   4416   
        val params = DynamoDbEndpointParameters {
 4473   4417   
            useFips = false
 4474   4418   
            useDualStack = false
 4475   4419   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 4476   4420   
            accountIdEndpointMode = "required"
 4477   4421   
            region = "us-east-1"
 4478   4422   
        }
 4479   4423   
        val ex = assertFailsWith<EndpointProviderException> {
 4480   4424   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4481   4425   
        }
 4482   4426   
        assertEquals("AccountIdEndpointMode is required but no AccountID was provided or able to be loaded", ex.message)
 4483   4427   
    }
 4484   4428   
 4485   4429   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=required, Region=us-east-1}
 4486   4430   
    @Test
 4487         -
    fun test239() = runTest {
        4431  +
    fun test235() = runTest {
 4488   4432   
        val params = DynamoDbEndpointParameters {
 4489   4433   
            useFips = false
 4490   4434   
            useDualStack = false
 4491   4435   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 4492   4436   
            accountIdEndpointMode = "required"
 4493   4437   
            region = "us-east-1"
 4494   4438   
        }
 4495   4439   
        val ex = assertFailsWith<EndpointProviderException> {
 4496   4440   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4497   4441   
        }
 4498   4442   
        assertEquals("AccountIdEndpointMode is required but no AccountID was provided or able to be loaded", ex.message)
 4499   4443   
    }
 4500   4444   
 4501   4445   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=required, Region=us-east-1}
 4502   4446   
    @Test
 4503         -
    fun test240() = runTest {
        4447  +
    fun test236() = runTest {
 4504   4448   
        val params = DynamoDbEndpointParameters {
 4505   4449   
            useFips = false
 4506   4450   
            useDualStack = false
 4507   4451   
            resourceArn = ""
 4508   4452   
            accountIdEndpointMode = "required"
 4509   4453   
            region = "us-east-1"
 4510   4454   
        }
 4511   4455   
        val ex = assertFailsWith<EndpointProviderException> {
 4512   4456   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4513   4457   
        }
 4514   4458   
        assertEquals("AccountIdEndpointMode is required but no AccountID was provided or able to be loaded", ex.message)
 4515   4459   
    }
 4516   4460   
 4517   4461   
    // {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
 4518   4462   
    @Test
 4519         -
    fun test241() = runTest {
        4463  +
    fun test237() = runTest {
 4520   4464   
        val params = DynamoDbEndpointParameters {
 4521   4465   
            useFips = true
 4522   4466   
            useDualStack = true
 4523   4467   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4524   4468   
            accountIdEndpointMode = "required"
 4525   4469   
            region = "us-east-1"
 4526   4470   
        }
 4527   4471   
        val ex = assertFailsWith<EndpointProviderException> {
 4528   4472   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4529   4473   
        }
 4530   4474   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported", ex.message)
 4531   4475   
    }
 4532   4476   
 4533   4477   
    // {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
 4534   4478   
    @Test
 4535         -
    fun test242() = runTest {
        4479  +
    fun test238() = runTest {
 4536   4480   
        val params = DynamoDbEndpointParameters {
 4537   4481   
            useFips = true
 4538   4482   
            useDualStack = false
 4539   4483   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4540   4484   
            accountIdEndpointMode = "required"
 4541   4485   
            region = "us-east-1"
 4542   4486   
        }
 4543   4487   
        val ex = assertFailsWith<EndpointProviderException> {
 4544   4488   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4545   4489   
        }
 4546   4490   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported", ex.message)
 4547   4491   
    }
 4548   4492   
 4549   4493   
    // {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
 4550   4494   
    @Test
 4551         -
    fun test243() = runTest {
        4495  +
    fun test239() = runTest {
 4552   4496   
        val params = DynamoDbEndpointParameters {
 4553   4497   
            useFips = false
 4554   4498   
            useDualStack = true
 4555   4499   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4556   4500   
            accountIdEndpointMode = "required"
 4557   4501   
            region = "us-east-1"
 4558   4502   
        }
 4559   4503   
        val ex = assertFailsWith<EndpointProviderException> {
 4560   4504   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4561   4505   
        }
 4562   4506   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported", ex.message)
 4563   4507   
    }
 4564   4508   
 4565   4509   
    // {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
 4566   4510   
    @Test
 4567         -
    fun test244() = runTest {
        4511  +
    fun test240() = runTest {
 4568   4512   
        val params = DynamoDbEndpointParameters {
 4569   4513   
            useFips = false
 4570   4514   
            useDualStack = false
 4571   4515   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4572   4516   
            accountIdEndpointMode = "required"
 4573   4517   
            region = "us-east-1"
 4574   4518   
        }
 4575   4519   
        val expected = Endpoint(
 4576   4520   
            uri = Url.parse("https://333333333333.ddb.us-east-1.amazonaws.com"),
 4577   4521   
        )
 4578   4522   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4579   4523   
        expectEqualEndpoints(expected, actual)
 4580   4524   
    }
 4581   4525   
 4582   4526   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=us-east-1}
 4583   4527   
    @Test
 4584         -
    fun test245() = runTest {
        4528  +
    fun test241() = runTest {
 4585   4529   
        val params = DynamoDbEndpointParameters {
 4586   4530   
            useFips = false
 4587   4531   
            useDualStack = false
 4588   4532   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4589   4533   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4590   4534   
            accountIdEndpointMode = "required"
 4591   4535   
            region = "us-east-1"
 4592   4536   
        }
 4593   4537   
        val expected = Endpoint(
 4594   4538   
            uri = Url.parse("https://222222222222.ddb.us-east-1.amazonaws.com"),
 4595   4539   
        )
 4596   4540   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4597   4541   
        expectEqualEndpoints(expected, actual)
 4598   4542   
    }
 4599   4543   
 4600   4544   
    // {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=required, Region=us-east-1}
 4601   4545   
    @Test
 4602         -
    fun test246() = runTest {
        4546  +
    fun test242() = runTest {
 4603   4547   
        val params = DynamoDbEndpointParameters {
 4604   4548   
            useFips = false
 4605   4549   
            useDualStack = false
 4606   4550   
            accountIdEndpointMode = "required"
 4607   4551   
            region = "us-east-1"
 4608   4552   
        }
 4609   4553   
        val ex = assertFailsWith<EndpointProviderException> {
 4610   4554   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4611   4555   
        }
 4612   4556   
        assertEquals("AccountIdEndpointMode is required but no AccountID was provided or able to be loaded", ex.message)
 4613   4557   
    }
 4614   4558   
 4615   4559   
    // {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=cn-north-1}
 4616   4560   
    @Test
 4617         -
    fun test247() = runTest {
        4561  +
    fun test243() = runTest {
 4618   4562   
        val params = DynamoDbEndpointParameters {
 4619   4563   
            useFips = true
 4620   4564   
            useDualStack = true
 4621   4565   
            accountId = "111111111111"
 4622   4566   
            accountIdEndpointMode = "required"
 4623   4567   
            region = "cn-north-1"
 4624   4568   
        }
 4625   4569   
        val ex = assertFailsWith<EndpointProviderException> {
 4626   4570   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4627   4571   
        }
 4628   4572   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported", ex.message)
 4629   4573   
    }
 4630   4574   
 4631   4575   
    // {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=cn-north-1}
 4632   4576   
    @Test
 4633         -
    fun test248() = runTest {
        4577  +
    fun test244() = runTest {
 4634   4578   
        val params = DynamoDbEndpointParameters {
 4635   4579   
            useFips = true
 4636   4580   
            useDualStack = false
 4637   4581   
            accountId = "111111111111"
 4638   4582   
            accountIdEndpointMode = "required"
 4639   4583   
            region = "cn-north-1"
 4640   4584   
        }
 4641   4585   
        val ex = assertFailsWith<EndpointProviderException> {
 4642   4586   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4643   4587   
        }
 4644   4588   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported", ex.message)
 4645   4589   
    }
 4646   4590   
 4647   4591   
    // {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=required, Region=cn-north-1}
 4648   4592   
    @Test
 4649         -
    fun test249() = runTest {
        4593  +
    fun test245() = runTest {
 4650   4594   
        val params = DynamoDbEndpointParameters {
 4651   4595   
            useFips = false
 4652   4596   
            useDualStack = true
 4653   4597   
            accountId = "111111111111"
 4654   4598   
            accountIdEndpointMode = "required"
 4655   4599   
            region = "cn-north-1"
 4656   4600   
        }
 4657   4601   
        val ex = assertFailsWith<EndpointProviderException> {
 4658   4602   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4659   4603   
        }
 4660   4604   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported", ex.message)
 4661   4605   
    }
 4662   4606   
 4663   4607   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=required, Region=cn-north-1}
 4664   4608   
    @Test
 4665         -
    fun test250() = runTest {
        4609  +
    fun test246() = runTest {
 4666   4610   
        val params = DynamoDbEndpointParameters {
 4667   4611   
            useFips = false
 4668   4612   
            useDualStack = false
 4669   4613   
            accountId = "111111111111"
 4670   4614   
            accountIdEndpointMode = "required"
 4671   4615   
            region = "cn-north-1"
 4672   4616   
        }
 4673   4617   
        val ex = assertFailsWith<EndpointProviderException> {
 4674   4618   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4675   4619   
        }
 4676   4620   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 4677   4621   
    }
 4678   4622   
 4679   4623   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}
 4680   4624   
    @Test
 4681         -
    fun test251() = runTest {
        4625  +
    fun test247() = runTest {
 4682   4626   
        val params = DynamoDbEndpointParameters {
 4683   4627   
            useFips = false
 4684   4628   
            useDualStack = false
 4685   4629   
            accountId = "111111111111"
 4686   4630   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4687   4631   
            accountIdEndpointMode = "required"
 4688   4632   
            region = "cn-north-1"
 4689   4633   
        }
 4690   4634   
        val ex = assertFailsWith<EndpointProviderException> {
 4691   4635   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4692   4636   
        }
 4693   4637   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 4694   4638   
    }
 4695   4639   
 4696   4640   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}
 4697   4641   
    @Test
 4698         -
    fun test252() = runTest {
        4642  +
    fun test248() = runTest {
 4699   4643   
        val params = DynamoDbEndpointParameters {
 4700   4644   
            useFips = false
 4701   4645   
            useDualStack = false
 4702   4646   
            accountId = "111111111111"
 4703   4647   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4704   4648   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4705   4649   
            accountIdEndpointMode = "required"
 4706   4650   
            region = "cn-north-1"
 4707   4651   
        }
 4708   4652   
        val ex = assertFailsWith<EndpointProviderException> {
 4709   4653   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4710   4654   
        }
 4711   4655   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 4712   4656   
    }
 4713   4657   
 4714   4658   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}
 4715   4659   
    @Test
 4716         -
    fun test253() = runTest {
        4660  +
    fun test249() = runTest {
 4717   4661   
        val params = DynamoDbEndpointParameters {
 4718   4662   
            useFips = false
 4719   4663   
            useDualStack = false
 4720   4664   
            accountId = "111111111111"
 4721   4665   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 4722   4666   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4723   4667   
            accountIdEndpointMode = "required"
 4724   4668   
            region = "cn-north-1"
 4725   4669   
        }
 4726   4670   
        val ex = assertFailsWith<EndpointProviderException> {
 4727   4671   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4728   4672   
        }
 4729   4673   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 4730   4674   
    }
 4731   4675   
 4732   4676   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}
 4733   4677   
    @Test
 4734         -
    fun test254() = runTest {
        4678  +
    fun test250() = runTest {
 4735   4679   
        val params = DynamoDbEndpointParameters {
 4736   4680   
            useFips = false
 4737   4681   
            useDualStack = false
 4738   4682   
            accountId = "111111111111"
 4739   4683   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 4740   4684   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4741   4685   
            accountIdEndpointMode = "required"
 4742   4686   
            region = "cn-north-1"
 4743   4687   
        }
 4744   4688   
        val ex = assertFailsWith<EndpointProviderException> {
 4745   4689   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4746   4690   
        }
 4747   4691   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 4748   4692   
    }
 4749   4693   
 4750   4694   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}
 4751   4695   
    @Test
 4752         -
    fun test255() = runTest {
        4696  +
    fun test251() = runTest {
 4753   4697   
        val params = DynamoDbEndpointParameters {
 4754   4698   
            useFips = false
 4755   4699   
            useDualStack = false
 4756   4700   
            accountId = "111111111111"
 4757   4701   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 4758   4702   
            resourceArnList = listOf("arn:aws:dynamodb:us-west-2:333333333333:table/table_name")
 4759   4703   
            accountIdEndpointMode = "required"
 4760   4704   
            region = "cn-north-1"
 4761   4705   
        }
 4762   4706   
        val ex = assertFailsWith<EndpointProviderException> {
 4763   4707   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4764   4708   
        }
 4765   4709   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 4766   4710   
    }
 4767   4711   
 4768   4712   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=required, Region=cn-north-1}
 4769   4713   
    @Test
 4770         -
    fun test256() = runTest {
        4714  +
    fun test252() = runTest {
 4771   4715   
        val params = DynamoDbEndpointParameters {
 4772   4716   
            useFips = false
 4773   4717   
            useDualStack = false
 4774   4718   
            accountId = "111111111111"
 4775   4719   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 4776   4720   
            resourceArnList = listOf("arn:aws:s3:us-east-1:333333333333:stream/testStream")
 4777   4721   
            accountIdEndpointMode = "required"
 4778   4722   
            region = "cn-north-1"
 4779   4723   
        }
 4780   4724   
        val ex = assertFailsWith<EndpointProviderException> {
 4781   4725   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4782   4726   
        }
 4783   4727   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 4784   4728   
    }
 4785   4729   
 4786   4730   
    // {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=required, Region=cn-north-1}
 4787   4731   
    @Test
 4788         -
    fun test257() = runTest {
        4732  +
    fun test253() = runTest {
 4789   4733   
        val params = DynamoDbEndpointParameters {
 4790   4734   
            useFips = false
 4791   4735   
            useDualStack = false
 4792   4736   
            accountId = ""
 4793   4737   
            accountIdEndpointMode = "required"
 4794   4738   
            region = "cn-north-1"
 4795   4739   
        }
 4796   4740   
        val ex = assertFailsWith<EndpointProviderException> {
 4797   4741   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4798   4742   
        }
 4799   4743   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 4800   4744   
    }
 4801   4745   
 4802   4746   
    // {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=cn-north-1}
 4803   4747   
    @Test
 4804         -
    fun test258() = runTest {
        4748  +
    fun test254() = runTest {
 4805   4749   
        val params = DynamoDbEndpointParameters {
 4806   4750   
            useFips = true
 4807   4751   
            useDualStack = true
 4808   4752   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4809   4753   
            accountIdEndpointMode = "required"
 4810   4754   
            region = "cn-north-1"
 4811   4755   
        }
 4812   4756   
        val ex = assertFailsWith<EndpointProviderException> {
 4813   4757   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4814   4758   
        }
 4815   4759   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported", ex.message)
 4816   4760   
    }
 4817   4761   
 4818   4762   
    // {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=cn-north-1}
 4819   4763   
    @Test
 4820         -
    fun test259() = runTest {
        4764  +
    fun test255() = runTest {
 4821   4765   
        val params = DynamoDbEndpointParameters {
 4822   4766   
            useFips = true
 4823   4767   
            useDualStack = false
 4824   4768   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4825   4769   
            accountIdEndpointMode = "required"
 4826   4770   
            region = "cn-north-1"
 4827   4771   
        }
 4828   4772   
        val ex = assertFailsWith<EndpointProviderException> {
 4829   4773   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4830   4774   
        }
 4831   4775   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported", ex.message)
 4832   4776   
    }
 4833   4777   
 4834   4778   
    // {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=cn-north-1}
 4835   4779   
    @Test
 4836         -
    fun test260() = runTest {
        4780  +
    fun test256() = runTest {
 4837   4781   
        val params = DynamoDbEndpointParameters {
 4838   4782   
            useFips = false
 4839   4783   
            useDualStack = true
 4840   4784   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4841   4785   
            accountIdEndpointMode = "required"
 4842   4786   
            region = "cn-north-1"
 4843   4787   
        }
 4844   4788   
        val ex = assertFailsWith<EndpointProviderException> {
 4845   4789   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4846   4790   
        }
 4847   4791   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported", ex.message)
 4848   4792   
    }
 4849   4793   
 4850   4794   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=required, Region=cn-north-1}
 4851   4795   
    @Test
 4852         -
    fun test261() = runTest {
        4796  +
    fun test257() = runTest {
 4853   4797   
        val params = DynamoDbEndpointParameters {
 4854   4798   
            useFips = false
 4855   4799   
            useDualStack = false
 4856   4800   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4857   4801   
            accountIdEndpointMode = "required"
 4858   4802   
            region = "cn-north-1"
 4859   4803   
        }
 4860   4804   
        val ex = assertFailsWith<EndpointProviderException> {
 4861   4805   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4862   4806   
        }
 4863   4807   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 4864   4808   
    }
 4865   4809   
 4866   4810   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=required, Region=cn-north-1}
 4867   4811   
    @Test
 4868         -
    fun test262() = runTest {
        4812  +
    fun test258() = runTest {
 4869   4813   
        val params = DynamoDbEndpointParameters {
 4870   4814   
            useFips = false
 4871   4815   
            useDualStack = false
 4872   4816   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 4873   4817   
            accountIdEndpointMode = "required"
 4874   4818   
            region = "cn-north-1"
 4875   4819   
        }
 4876   4820   
        val ex = assertFailsWith<EndpointProviderException> {
 4877   4821   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4878   4822   
        }
 4879   4823   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 4880   4824   
    }
 4881   4825   
 4882   4826   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=required, Region=cn-north-1}
 4883   4827   
    @Test
 4884         -
    fun test263() = runTest {
        4828  +
    fun test259() = runTest {
 4885   4829   
        val params = DynamoDbEndpointParameters {
 4886   4830   
            useFips = false
 4887   4831   
            useDualStack = false
 4888   4832   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 4889   4833   
            accountIdEndpointMode = "required"
 4890   4834   
            region = "cn-north-1"
 4891   4835   
        }
 4892   4836   
        val ex = assertFailsWith<EndpointProviderException> {
 4893   4837   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4894   4838   
        }
 4895   4839   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 4896   4840   
    }
 4897   4841   
 4898   4842   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=required, Region=cn-north-1}
 4899   4843   
    @Test
 4900         -
    fun test264() = runTest {
        4844  +
    fun test260() = runTest {
 4901   4845   
        val params = DynamoDbEndpointParameters {
 4902   4846   
            useFips = false
 4903   4847   
            useDualStack = false
 4904   4848   
            resourceArn = ""
 4905   4849   
            accountIdEndpointMode = "required"
 4906   4850   
            region = "cn-north-1"
 4907   4851   
        }
 4908   4852   
        val ex = assertFailsWith<EndpointProviderException> {
 4909   4853   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4910   4854   
        }
 4911   4855   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 4912   4856   
    }
 4913   4857   
 4914   4858   
    // {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}
 4915   4859   
    @Test
 4916         -
    fun test265() = runTest {
        4860  +
    fun test261() = runTest {
 4917   4861   
        val params = DynamoDbEndpointParameters {
 4918   4862   
            useFips = true
 4919   4863   
            useDualStack = true
 4920   4864   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4921   4865   
            accountIdEndpointMode = "required"
 4922   4866   
            region = "cn-north-1"
 4923   4867   
        }
 4924   4868   
        val ex = assertFailsWith<EndpointProviderException> {
 4925   4869   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4926   4870   
        }
 4927   4871   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported", ex.message)
 4928   4872   
    }
 4929   4873   
 4930   4874   
    // {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}
 4931   4875   
    @Test
 4932         -
    fun test266() = runTest {
        4876  +
    fun test262() = runTest {
 4933   4877   
        val params = DynamoDbEndpointParameters {
 4934   4878   
            useFips = true
 4935   4879   
            useDualStack = false
 4936   4880   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4937   4881   
            accountIdEndpointMode = "required"
 4938   4882   
            region = "cn-north-1"
 4939   4883   
        }
 4940   4884   
        val ex = assertFailsWith<EndpointProviderException> {
 4941   4885   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4942   4886   
        }
 4943   4887   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and FIPS is enabled, but FIPS account endpoints are not supported", ex.message)
 4944   4888   
    }
 4945   4889   
 4946   4890   
    // {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}
 4947   4891   
    @Test
 4948         -
    fun test267() = runTest {
        4892  +
    fun test263() = runTest {
 4949   4893   
        val params = DynamoDbEndpointParameters {
 4950   4894   
            useFips = false
 4951   4895   
            useDualStack = true
 4952   4896   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4953   4897   
            accountIdEndpointMode = "required"
 4954   4898   
            region = "cn-north-1"
 4955   4899   
        }
 4956   4900   
        val ex = assertFailsWith<EndpointProviderException> {
 4957   4901   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4958   4902   
        }
 4959   4903   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required and DualStack is enabled, but DualStack account endpoints are not supported", ex.message)
 4960   4904   
    }
 4961   4905   
 4962   4906   
    // {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}
 4963   4907   
    @Test
 4964         -
    fun test268() = runTest {
        4908  +
    fun test264() = runTest {
 4965   4909   
        val params = DynamoDbEndpointParameters {
 4966   4910   
            useFips = false
 4967   4911   
            useDualStack = false
 4968   4912   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4969   4913   
            accountIdEndpointMode = "required"
 4970   4914   
            region = "cn-north-1"
 4971   4915   
        }
 4972   4916   
        val ex = assertFailsWith<EndpointProviderException> {
 4973   4917   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4974   4918   
        }
 4975   4919   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 4976   4920   
    }
 4977   4921   
 4978   4922   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=required, Region=cn-north-1}
 4979   4923   
    @Test
 4980         -
    fun test269() = runTest {
        4924  +
    fun test265() = runTest {
 4981   4925   
        val params = DynamoDbEndpointParameters {
 4982   4926   
            useFips = false
 4983   4927   
            useDualStack = false
 4984   4928   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 4985   4929   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 4986   4930   
            accountIdEndpointMode = "required"
 4987   4931   
            region = "cn-north-1"
 4988   4932   
        }
 4989   4933   
        val ex = assertFailsWith<EndpointProviderException> {
 4990   4934   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 4991   4935   
        }
 4992   4936   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 4993   4937   
    }
 4994   4938   
 4995   4939   
    // {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=required, Region=cn-north-1}
 4996   4940   
    @Test
 4997         -
    fun test270() = runTest {
        4941  +
    fun test266() = runTest {
 4998   4942   
        val params = DynamoDbEndpointParameters {
 4999   4943   
            useFips = false
 5000   4944   
            useDualStack = false
 5001   4945   
            accountIdEndpointMode = "required"
 5002   4946   
            region = "cn-north-1"
 5003   4947   
        }
 5004   4948   
        val ex = assertFailsWith<EndpointProviderException> {
 5005   4949   
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5006   4950   
        }
 5007   4951   
        assertEquals("Invalid Configuration: AccountIdEndpointMode is required but account endpoints are not supported in this partition", ex.message)
 5008   4952   
    }
 5009   4953   
 5010   4954   
    // {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=us-east-1}
 5011   4955   
    @Test
 5012         -
    fun test271() = runTest {
        4956  +
    fun test267() = runTest {
 5013   4957   
        val params = DynamoDbEndpointParameters {
 5014   4958   
            useFips = true
 5015   4959   
            useDualStack = true
 5016   4960   
            accountId = "111111111111"
 5017   4961   
            accountIdEndpointMode = "disabled"
 5018   4962   
            region = "us-east-1"
 5019   4963   
        }
 5020   4964   
        val expected = Endpoint(
 5021   4965   
            uri = Url.parse("https://dynamodb-fips.us-east-1.api.aws"),
 5022   4966   
        )
 5023   4967   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5024   4968   
        expectEqualEndpoints(expected, actual)
 5025   4969   
    }
 5026   4970   
 5027   4971   
    // {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=us-east-1}
 5028   4972   
    @Test
 5029         -
    fun test272() = runTest {
        4973  +
    fun test268() = runTest {
 5030   4974   
        val params = DynamoDbEndpointParameters {
 5031   4975   
            useFips = true
 5032   4976   
            useDualStack = false
 5033   4977   
            accountId = "111111111111"
 5034   4978   
            accountIdEndpointMode = "disabled"
 5035   4979   
            region = "us-east-1"
 5036   4980   
        }
 5037   4981   
        val expected = Endpoint(
 5038   4982   
            uri = Url.parse("https://dynamodb-fips.us-east-1.amazonaws.com"),
 5039   4983   
        )
 5040   4984   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5041   4985   
        expectEqualEndpoints(expected, actual)
 5042   4986   
    }
 5043   4987   
 5044   4988   
    // {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=us-east-1}
 5045   4989   
    @Test
 5046         -
    fun test273() = runTest {
        4990  +
    fun test269() = runTest {
 5047   4991   
        val params = DynamoDbEndpointParameters {
 5048   4992   
            useFips = false
 5049   4993   
            useDualStack = true
 5050   4994   
            accountId = "111111111111"
 5051   4995   
            accountIdEndpointMode = "disabled"
 5052   4996   
            region = "us-east-1"
 5053   4997   
        }
 5054   4998   
        val expected = Endpoint(
 5055   4999   
            uri = Url.parse("https://dynamodb.us-east-1.api.aws"),
 5056   5000   
        )
 5057   5001   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5058   5002   
        expectEqualEndpoints(expected, actual)
 5059   5003   
    }
 5060   5004   
 5061   5005   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=disabled, Region=us-east-1}
 5062   5006   
    @Test
 5063         -
    fun test274() = runTest {
        5007  +
    fun test270() = runTest {
 5064   5008   
        val params = DynamoDbEndpointParameters {
 5065   5009   
            useFips = false
 5066   5010   
            useDualStack = false
 5067   5011   
            accountId = "111111111111"
 5068   5012   
            accountIdEndpointMode = "disabled"
 5069   5013   
            region = "us-east-1"
 5070   5014   
        }
 5071   5015   
        val expected = Endpoint(
 5072   5016   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5073   5017   
        )
 5074   5018   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5075   5019   
        expectEqualEndpoints(expected, actual)
 5076   5020   
    }
 5077   5021   
 5078   5022   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1}
 5079   5023   
    @Test
 5080         -
    fun test275() = runTest {
        5024  +
    fun test271() = runTest {
 5081   5025   
        val params = DynamoDbEndpointParameters {
 5082   5026   
            useFips = false
 5083   5027   
            useDualStack = false
 5084   5028   
            accountId = "111111111111"
 5085   5029   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5086   5030   
            accountIdEndpointMode = "disabled"
 5087   5031   
            region = "us-east-1"
 5088   5032   
        }
 5089   5033   
        val expected = Endpoint(
 5090   5034   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5091   5035   
        )
 5092   5036   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5093   5037   
        expectEqualEndpoints(expected, actual)
 5094   5038   
    }
 5095   5039   
 5096   5040   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1}
 5097   5041   
    @Test
 5098         -
    fun test276() = runTest {
        5042  +
    fun test272() = runTest {
 5099   5043   
        val params = DynamoDbEndpointParameters {
 5100   5044   
            useFips = false
 5101   5045   
            useDualStack = false
 5102   5046   
            accountId = "111111111111"
 5103   5047   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 5104   5048   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5105   5049   
            accountIdEndpointMode = "disabled"
 5106   5050   
            region = "us-east-1"
 5107   5051   
        }
 5108   5052   
        val expected = Endpoint(
 5109   5053   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5110   5054   
        )
 5111   5055   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5112   5056   
        expectEqualEndpoints(expected, actual)
 5113   5057   
    }
 5114   5058   
 5115   5059   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1}
 5116   5060   
    @Test
 5117         -
    fun test277() = runTest {
        5061  +
    fun test273() = runTest {
 5118   5062   
        val params = DynamoDbEndpointParameters {
 5119   5063   
            useFips = false
 5120   5064   
            useDualStack = false
 5121   5065   
            accountId = "111111111111"
 5122   5066   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 5123   5067   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5124   5068   
            accountIdEndpointMode = "disabled"
 5125   5069   
            region = "us-east-1"
 5126   5070   
        }
 5127   5071   
        val expected = Endpoint(
 5128   5072   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5129   5073   
        )
 5130   5074   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5131   5075   
        expectEqualEndpoints(expected, actual)
 5132   5076   
    }
 5133   5077   
 5134   5078   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1}
 5135   5079   
    @Test
 5136         -
    fun test278() = runTest {
        5080  +
    fun test274() = runTest {
 5137   5081   
        val params = DynamoDbEndpointParameters {
 5138   5082   
            useFips = false
 5139   5083   
            useDualStack = false
 5140   5084   
            accountId = "111111111111"
 5141   5085   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 5142   5086   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5143   5087   
            accountIdEndpointMode = "disabled"
 5144   5088   
            region = "us-east-1"
 5145   5089   
        }
 5146   5090   
        val expected = Endpoint(
 5147   5091   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5148   5092   
        )
 5149   5093   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5150   5094   
        expectEqualEndpoints(expected, actual)
 5151   5095   
    }
 5152   5096   
 5153   5097   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1}
 5154   5098   
    @Test
 5155         -
    fun test279() = runTest {
        5099  +
    fun test275() = runTest {
 5156   5100   
        val params = DynamoDbEndpointParameters {
 5157   5101   
            useFips = false
 5158   5102   
            useDualStack = false
 5159   5103   
            accountId = "111111111111"
 5160   5104   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 5161   5105   
            resourceArnList = listOf("arn:aws:dynamodb:us-west-2:333333333333:table/table_name")
 5162   5106   
            accountIdEndpointMode = "disabled"
 5163   5107   
            region = "us-east-1"
 5164   5108   
        }
 5165   5109   
        val expected = Endpoint(
 5166   5110   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5167   5111   
        )
 5168   5112   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5169   5113   
        expectEqualEndpoints(expected, actual)
 5170   5114   
    }
 5171   5115   
 5172   5116   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=disabled, Region=us-east-1}
 5173   5117   
    @Test
 5174         -
    fun test280() = runTest {
        5118  +
    fun test276() = runTest {
 5175   5119   
        val params = DynamoDbEndpointParameters {
 5176   5120   
            useFips = false
 5177   5121   
            useDualStack = false
 5178   5122   
            accountId = "111111111111"
 5179   5123   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 5180   5124   
            resourceArnList = listOf("arn:aws:s3:us-east-1:333333333333:stream/testStream")
 5181   5125   
            accountIdEndpointMode = "disabled"
 5182   5126   
            region = "us-east-1"
 5183   5127   
        }
 5184   5128   
        val expected = Endpoint(
 5185   5129   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5186   5130   
        )
 5187   5131   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5188   5132   
        expectEqualEndpoints(expected, actual)
 5189   5133   
    }
 5190   5134   
 5191   5135   
    // {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=disabled, Region=us-east-1}
 5192   5136   
    @Test
 5193         -
    fun test281() = runTest {
        5137  +
    fun test277() = runTest {
 5194   5138   
        val params = DynamoDbEndpointParameters {
 5195   5139   
            useFips = false
 5196   5140   
            useDualStack = false
 5197   5141   
            accountId = ""
 5198   5142   
            accountIdEndpointMode = "disabled"
 5199   5143   
            region = "us-east-1"
 5200   5144   
        }
 5201   5145   
        val expected = Endpoint(
 5202   5146   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5203   5147   
        )
 5204   5148   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5205   5149   
        expectEqualEndpoints(expected, actual)
 5206   5150   
    }
 5207   5151   
 5208   5152   
    // {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=us-east-1}
 5209   5153   
    @Test
 5210         -
    fun test282() = runTest {
        5154  +
    fun test278() = runTest {
 5211   5155   
        val params = DynamoDbEndpointParameters {
 5212   5156   
            useFips = true
 5213   5157   
            useDualStack = true
 5214   5158   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 5215   5159   
            accountIdEndpointMode = "disabled"
 5216   5160   
            region = "us-east-1"
 5217   5161   
        }
 5218   5162   
        val expected = Endpoint(
 5219   5163   
            uri = Url.parse("https://dynamodb-fips.us-east-1.api.aws"),
 5220   5164   
        )
 5221   5165   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5222   5166   
        expectEqualEndpoints(expected, actual)
 5223   5167   
    }
 5224   5168   
 5225   5169   
    // {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=us-east-1}
 5226   5170   
    @Test
 5227         -
    fun test283() = runTest {
        5171  +
    fun test279() = runTest {
 5228   5172   
        val params = DynamoDbEndpointParameters {
 5229   5173   
            useFips = true
 5230   5174   
            useDualStack = false
 5231   5175   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 5232   5176   
            accountIdEndpointMode = "disabled"
 5233   5177   
            region = "us-east-1"
 5234   5178   
        }
 5235   5179   
        val expected = Endpoint(
 5236   5180   
            uri = Url.parse("https://dynamodb-fips.us-east-1.amazonaws.com"),
 5237   5181   
        )
 5238   5182   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5239   5183   
        expectEqualEndpoints(expected, actual)
 5240   5184   
    }
 5241   5185   
 5242   5186   
    // {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=us-east-1}
 5243   5187   
    @Test
 5244         -
    fun test284() = runTest {
        5188  +
    fun test280() = runTest {
 5245   5189   
        val params = DynamoDbEndpointParameters {
 5246   5190   
            useFips = false
 5247   5191   
            useDualStack = true
 5248   5192   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 5249   5193   
            accountIdEndpointMode = "disabled"
 5250   5194   
            region = "us-east-1"
 5251   5195   
        }
 5252   5196   
        val expected = Endpoint(
 5253   5197   
            uri = Url.parse("https://dynamodb.us-east-1.api.aws"),
 5254   5198   
        )
 5255   5199   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5256   5200   
        expectEqualEndpoints(expected, actual)
 5257   5201   
    }
 5258   5202   
 5259   5203   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=us-east-1}
 5260   5204   
    @Test
 5261         -
    fun test285() = runTest {
        5205  +
    fun test281() = runTest {
 5262   5206   
        val params = DynamoDbEndpointParameters {
 5263   5207   
            useFips = false
 5264   5208   
            useDualStack = false
 5265   5209   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 5266   5210   
            accountIdEndpointMode = "disabled"
 5267   5211   
            region = "us-east-1"
 5268   5212   
        }
 5269   5213   
        val expected = Endpoint(
 5270   5214   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5271   5215   
        )
 5272   5216   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5273   5217   
        expectEqualEndpoints(expected, actual)
 5274   5218   
    }
 5275   5219   
 5276   5220   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=disabled, Region=us-east-1}
 5277   5221   
    @Test
 5278         -
    fun test286() = runTest {
        5222  +
    fun test282() = runTest {
 5279   5223   
        val params = DynamoDbEndpointParameters {
 5280   5224   
            useFips = false
 5281   5225   
            useDualStack = false
 5282   5226   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 5283   5227   
            accountIdEndpointMode = "disabled"
 5284   5228   
            region = "us-east-1"
 5285   5229   
        }
 5286   5230   
        val expected = Endpoint(
 5287   5231   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5288   5232   
        )
 5289   5233   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5290   5234   
        expectEqualEndpoints(expected, actual)
 5291   5235   
    }
 5292   5236   
 5293   5237   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=disabled, Region=us-east-1}
 5294   5238   
    @Test
 5295         -
    fun test287() = runTest {
        5239  +
    fun test283() = runTest {
 5296   5240   
        val params = DynamoDbEndpointParameters {
 5297   5241   
            useFips = false
 5298   5242   
            useDualStack = false
 5299   5243   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 5300   5244   
            accountIdEndpointMode = "disabled"
 5301   5245   
            region = "us-east-1"
 5302   5246   
        }
 5303   5247   
        val expected = Endpoint(
 5304   5248   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5305   5249   
        )
 5306   5250   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5307   5251   
        expectEqualEndpoints(expected, actual)
 5308   5252   
    }
 5309   5253   
 5310   5254   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=disabled, Region=us-east-1}
 5311   5255   
    @Test
 5312         -
    fun test288() = runTest {
        5256  +
    fun test284() = runTest {
 5313   5257   
        val params = DynamoDbEndpointParameters {
 5314   5258   
            useFips = false
 5315   5259   
            useDualStack = false
 5316   5260   
            resourceArn = ""
 5317   5261   
            accountIdEndpointMode = "disabled"
 5318   5262   
            region = "us-east-1"
 5319   5263   
        }
 5320   5264   
        val expected = Endpoint(
 5321   5265   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5322   5266   
        )
 5323   5267   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5324   5268   
        expectEqualEndpoints(expected, actual)
 5325   5269   
    }
 5326   5270   
 5327   5271   
    // {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1}
 5328   5272   
    @Test
 5329         -
    fun test289() = runTest {
        5273  +
    fun test285() = runTest {
 5330   5274   
        val params = DynamoDbEndpointParameters {
 5331   5275   
            useFips = true
 5332   5276   
            useDualStack = true
 5333   5277   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5334   5278   
            accountIdEndpointMode = "disabled"
 5335   5279   
            region = "us-east-1"
 5336   5280   
        }
 5337   5281   
        val expected = Endpoint(
 5338   5282   
            uri = Url.parse("https://dynamodb-fips.us-east-1.api.aws"),
 5339   5283   
        )
 5340   5284   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5341   5285   
        expectEqualEndpoints(expected, actual)
 5342   5286   
    }
 5343   5287   
 5344   5288   
    // {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1}
 5345   5289   
    @Test
 5346         -
    fun test290() = runTest {
        5290  +
    fun test286() = runTest {
 5347   5291   
        val params = DynamoDbEndpointParameters {
 5348   5292   
            useFips = true
 5349   5293   
            useDualStack = false
 5350   5294   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5351   5295   
            accountIdEndpointMode = "disabled"
 5352   5296   
            region = "us-east-1"
 5353   5297   
        }
 5354   5298   
        val expected = Endpoint(
 5355   5299   
            uri = Url.parse("https://dynamodb-fips.us-east-1.amazonaws.com"),
 5356   5300   
        )
 5357   5301   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5358   5302   
        expectEqualEndpoints(expected, actual)
 5359   5303   
    }
 5360   5304   
 5361   5305   
    // {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1}
 5362   5306   
    @Test
 5363         -
    fun test291() = runTest {
        5307  +
    fun test287() = runTest {
 5364   5308   
        val params = DynamoDbEndpointParameters {
 5365   5309   
            useFips = false
 5366   5310   
            useDualStack = true
 5367   5311   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5368   5312   
            accountIdEndpointMode = "disabled"
 5369   5313   
            region = "us-east-1"
 5370   5314   
        }
 5371   5315   
        val expected = Endpoint(
 5372   5316   
            uri = Url.parse("https://dynamodb.us-east-1.api.aws"),
 5373   5317   
        )
 5374   5318   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5375   5319   
        expectEqualEndpoints(expected, actual)
 5376   5320   
    }
 5377   5321   
 5378   5322   
    // {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1}
 5379   5323   
    @Test
 5380         -
    fun test292() = runTest {
        5324  +
    fun test288() = runTest {
 5381   5325   
        val params = DynamoDbEndpointParameters {
 5382   5326   
            useFips = false
 5383   5327   
            useDualStack = false
 5384   5328   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5385   5329   
            accountIdEndpointMode = "disabled"
 5386   5330   
            region = "us-east-1"
 5387   5331   
        }
 5388   5332   
        val expected = Endpoint(
 5389   5333   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5390   5334   
        )
 5391   5335   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5392   5336   
        expectEqualEndpoints(expected, actual)
 5393   5337   
    }
 5394   5338   
 5395   5339   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=disabled, Region=us-east-1}
 5396   5340   
    @Test
 5397         -
    fun test293() = runTest {
        5341  +
    fun test289() = runTest {
 5398   5342   
        val params = DynamoDbEndpointParameters {
 5399   5343   
            useFips = false
 5400   5344   
            useDualStack = false
 5401   5345   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 5402   5346   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5403   5347   
            accountIdEndpointMode = "disabled"
 5404   5348   
            region = "us-east-1"
 5405   5349   
        }
 5406   5350   
        val expected = Endpoint(
 5407   5351   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5408   5352   
        )
 5409   5353   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5410   5354   
        expectEqualEndpoints(expected, actual)
 5411   5355   
    }
 5412   5356   
 5413   5357   
    // {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=disabled, Region=us-east-1}
 5414   5358   
    @Test
 5415         -
    fun test294() = runTest {
        5359  +
    fun test290() = runTest {
 5416   5360   
        val params = DynamoDbEndpointParameters {
 5417   5361   
            useFips = false
 5418   5362   
            useDualStack = false
 5419   5363   
            accountIdEndpointMode = "disabled"
 5420   5364   
            region = "us-east-1"
 5421   5365   
        }
 5422   5366   
        val expected = Endpoint(
 5423   5367   
            uri = Url.parse("https://dynamodb.us-east-1.amazonaws.com"),
 5424   5368   
        )
 5425   5369   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5426   5370   
        expectEqualEndpoints(expected, actual)
 5427   5371   
    }
 5428   5372   
 5429   5373   
    // {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=cn-north-1}
 5430   5374   
    @Test
 5431         -
    fun test295() = runTest {
        5375  +
    fun test291() = runTest {
 5432   5376   
        val params = DynamoDbEndpointParameters {
 5433   5377   
            useFips = true
 5434   5378   
            useDualStack = true
 5435   5379   
            accountId = "111111111111"
 5436   5380   
            accountIdEndpointMode = "preferred"
 5437   5381   
            region = "cn-north-1"
 5438   5382   
        }
 5439   5383   
        val expected = Endpoint(
 5440   5384   
            uri = Url.parse("https://dynamodb-fips.cn-north-1.api.amazonwebservices.com.cn"),
 5441   5385   
        )
 5442   5386   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5443   5387   
        expectEqualEndpoints(expected, actual)
 5444   5388   
    }
 5445   5389   
 5446   5390   
    // {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=cn-north-1}
 5447   5391   
    @Test
 5448         -
    fun test296() = runTest {
        5392  +
    fun test292() = runTest {
 5449   5393   
        val params = DynamoDbEndpointParameters {
 5450   5394   
            useFips = true
 5451   5395   
            useDualStack = false
 5452   5396   
            accountId = "111111111111"
 5453   5397   
            accountIdEndpointMode = "preferred"
 5454   5398   
            region = "cn-north-1"
 5455   5399   
        }
 5456   5400   
        val expected = Endpoint(
 5457   5401   
            uri = Url.parse("https://dynamodb-fips.cn-north-1.amazonaws.com.cn"),
 5458   5402   
        )
 5459   5403   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5460   5404   
        expectEqualEndpoints(expected, actual)
 5461   5405   
    }
 5462   5406   
 5463   5407   
    // {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=cn-north-1}
 5464   5408   
    @Test
 5465         -
    fun test297() = runTest {
        5409  +
    fun test293() = runTest {
 5466   5410   
        val params = DynamoDbEndpointParameters {
 5467   5411   
            useFips = false
 5468   5412   
            useDualStack = true
 5469   5413   
            accountId = "111111111111"
 5470   5414   
            accountIdEndpointMode = "preferred"
 5471   5415   
            region = "cn-north-1"
 5472   5416   
        }
 5473   5417   
        val expected = Endpoint(
 5474   5418   
            uri = Url.parse("https://dynamodb.cn-north-1.api.amazonwebservices.com.cn"),
 5475   5419   
        )
 5476   5420   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5477   5421   
        expectEqualEndpoints(expected, actual)
 5478   5422   
    }
 5479   5423   
 5480   5424   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=cn-north-1}
 5481   5425   
    @Test
 5482         -
    fun test298() = runTest {
        5426  +
    fun test294() = runTest {
 5483   5427   
        val params = DynamoDbEndpointParameters {
 5484   5428   
            useFips = false
 5485   5429   
            useDualStack = false
 5486   5430   
            accountId = "111111111111"
 5487   5431   
            accountIdEndpointMode = "preferred"
 5488   5432   
            region = "cn-north-1"
 5489   5433   
        }
 5490   5434   
        val expected = Endpoint(
 5491   5435   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5492   5436   
        )
 5493   5437   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5494   5438   
        expectEqualEndpoints(expected, actual)
 5495   5439   
    }
 5496   5440   
 5497   5441   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=cn-north-1}
 5498   5442   
    @Test
 5499         -
    fun test299() = runTest {
        5443  +
    fun test295() = runTest {
 5500   5444   
        val params = DynamoDbEndpointParameters {
 5501   5445   
            useFips = false
 5502   5446   
            useDualStack = false
 5503   5447   
            accountId = "111111111111"
 5504   5448   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5505   5449   
            accountIdEndpointMode = "preferred"
 5506   5450   
            region = "cn-north-1"
 5507   5451   
        }
 5508   5452   
        val expected = Endpoint(
 5509   5453   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5510   5454   
        )
 5511   5455   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5512   5456   
        expectEqualEndpoints(expected, actual)
 5513   5457   
    }
 5514   5458   
 5515   5459   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=cn-north-1}
 5516   5460   
    @Test
 5517         -
    fun test300() = runTest {
        5461  +
    fun test296() = runTest {
 5518   5462   
        val params = DynamoDbEndpointParameters {
 5519   5463   
            useFips = false
 5520   5464   
            useDualStack = false
 5521   5465   
            accountId = "111111111111"
 5522   5466   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 5523   5467   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5524   5468   
            accountIdEndpointMode = "preferred"
 5525   5469   
            region = "cn-north-1"
 5526   5470   
        }
 5527   5471   
        val expected = Endpoint(
 5528   5472   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5529   5473   
        )
 5530   5474   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5531   5475   
        expectEqualEndpoints(expected, actual)
 5532   5476   
    }
 5533   5477   
 5534   5478   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=cn-north-1}
 5535   5479   
    @Test
 5536         -
    fun test301() = runTest {
        5480  +
    fun test297() = runTest {
 5537   5481   
        val params = DynamoDbEndpointParameters {
 5538   5482   
            useFips = false
 5539   5483   
            useDualStack = false
 5540   5484   
            accountId = "111111111111"
 5541   5485   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 5542   5486   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5543   5487   
            accountIdEndpointMode = "preferred"
 5544   5488   
            region = "cn-north-1"
 5545   5489   
        }
 5546   5490   
        val expected = Endpoint(
 5547   5491   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5548   5492   
        )
 5549   5493   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5550   5494   
        expectEqualEndpoints(expected, actual)
 5551   5495   
    }
 5552   5496   
 5553   5497   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=cn-north-1}
 5554   5498   
    @Test
 5555         -
    fun test302() = runTest {
        5499  +
    fun test298() = runTest {
 5556   5500   
        val params = DynamoDbEndpointParameters {
 5557   5501   
            useFips = false
 5558   5502   
            useDualStack = false
 5559   5503   
            accountId = "111111111111"
 5560   5504   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 5561   5505   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5562   5506   
            accountIdEndpointMode = "preferred"
 5563   5507   
            region = "cn-north-1"
 5564   5508   
        }
 5565   5509   
        val expected = Endpoint(
 5566   5510   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5567   5511   
        )
 5568   5512   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5569   5513   
        expectEqualEndpoints(expected, actual)
 5570   5514   
    }
 5571   5515   
 5572   5516   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=cn-north-1}
 5573   5517   
    @Test
 5574         -
    fun test303() = runTest {
        5518  +
    fun test299() = runTest {
 5575   5519   
        val params = DynamoDbEndpointParameters {
 5576   5520   
            useFips = false
 5577   5521   
            useDualStack = false
 5578   5522   
            accountId = "111111111111"
 5579   5523   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 5580   5524   
            resourceArnList = listOf("arn:aws:dynamodb:us-west-2:333333333333:table/table_name")
 5581   5525   
            accountIdEndpointMode = "preferred"
 5582   5526   
            region = "cn-north-1"
 5583   5527   
        }
 5584   5528   
        val expected = Endpoint(
 5585   5529   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5586   5530   
        )
 5587   5531   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5588   5532   
        expectEqualEndpoints(expected, actual)
 5589   5533   
    }
 5590   5534   
 5591   5535   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=preferred, Region=cn-north-1}
 5592   5536   
    @Test
 5593         -
    fun test304() = runTest {
        5537  +
    fun test300() = runTest {
 5594   5538   
        val params = DynamoDbEndpointParameters {
 5595   5539   
            useFips = false
 5596   5540   
            useDualStack = false
 5597   5541   
            accountId = "111111111111"
 5598   5542   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 5599   5543   
            resourceArnList = listOf("arn:aws:s3:us-east-1:333333333333:stream/testStream")
 5600   5544   
            accountIdEndpointMode = "preferred"
 5601   5545   
            region = "cn-north-1"
 5602   5546   
        }
 5603   5547   
        val expected = Endpoint(
 5604   5548   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5605   5549   
        )
 5606   5550   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5607   5551   
        expectEqualEndpoints(expected, actual)
 5608   5552   
    }
 5609   5553   
 5610   5554   
    // {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=preferred, Region=cn-north-1}
 5611   5555   
    @Test
 5612         -
    fun test305() = runTest {
        5556  +
    fun test301() = runTest {
 5613   5557   
        val params = DynamoDbEndpointParameters {
 5614   5558   
            useFips = false
 5615   5559   
            useDualStack = false
 5616   5560   
            accountId = ""
 5617   5561   
            accountIdEndpointMode = "preferred"
 5618   5562   
            region = "cn-north-1"
 5619   5563   
        }
 5620   5564   
        val expected = Endpoint(
 5621   5565   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5622   5566   
        )
 5623   5567   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5624   5568   
        expectEqualEndpoints(expected, actual)
 5625   5569   
    }
 5626   5570   
 5627   5571   
    // {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=cn-north-1}
 5628   5572   
    @Test
 5629         -
    fun test306() = runTest {
        5573  +
    fun test302() = runTest {
 5630   5574   
        val params = DynamoDbEndpointParameters {
 5631   5575   
            useFips = true
 5632   5576   
            useDualStack = true
 5633   5577   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 5634   5578   
            accountIdEndpointMode = "preferred"
 5635   5579   
            region = "cn-north-1"
 5636   5580   
        }
 5637   5581   
        val expected = Endpoint(
 5638   5582   
            uri = Url.parse("https://dynamodb-fips.cn-north-1.api.amazonwebservices.com.cn"),
 5639   5583   
        )
 5640   5584   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5641   5585   
        expectEqualEndpoints(expected, actual)
 5642   5586   
    }
 5643   5587   
 5644   5588   
    // {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=cn-north-1}
 5645   5589   
    @Test
 5646         -
    fun test307() = runTest {
        5590  +
    fun test303() = runTest {
 5647   5591   
        val params = DynamoDbEndpointParameters {
 5648   5592   
            useFips = true
 5649   5593   
            useDualStack = false
 5650   5594   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 5651   5595   
            accountIdEndpointMode = "preferred"
 5652   5596   
            region = "cn-north-1"
 5653   5597   
        }
 5654   5598   
        val expected = Endpoint(
 5655   5599   
            uri = Url.parse("https://dynamodb-fips.cn-north-1.amazonaws.com.cn"),
 5656   5600   
        )
 5657   5601   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5658   5602   
        expectEqualEndpoints(expected, actual)
 5659   5603   
    }
 5660   5604   
 5661   5605   
    // {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=cn-north-1}
 5662   5606   
    @Test
 5663         -
    fun test308() = runTest {
        5607  +
    fun test304() = runTest {
 5664   5608   
        val params = DynamoDbEndpointParameters {
 5665   5609   
            useFips = false
 5666   5610   
            useDualStack = true
 5667   5611   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 5668   5612   
            accountIdEndpointMode = "preferred"
 5669   5613   
            region = "cn-north-1"
 5670   5614   
        }
 5671   5615   
        val expected = Endpoint(
 5672   5616   
            uri = Url.parse("https://dynamodb.cn-north-1.api.amazonwebservices.com.cn"),
 5673   5617   
        )
 5674   5618   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5675   5619   
        expectEqualEndpoints(expected, actual)
 5676   5620   
    }
 5677   5621   
 5678   5622   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=cn-north-1}
 5679   5623   
    @Test
 5680         -
    fun test309() = runTest {
        5624  +
    fun test305() = runTest {
 5681   5625   
        val params = DynamoDbEndpointParameters {
 5682   5626   
            useFips = false
 5683   5627   
            useDualStack = false
 5684   5628   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 5685   5629   
            accountIdEndpointMode = "preferred"
 5686   5630   
            region = "cn-north-1"
 5687   5631   
        }
 5688   5632   
        val expected = Endpoint(
 5689   5633   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5690   5634   
        )
 5691   5635   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5692   5636   
        expectEqualEndpoints(expected, actual)
 5693   5637   
    }
 5694   5638   
 5695   5639   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=cn-north-1}
 5696   5640   
    @Test
 5697         -
    fun test310() = runTest {
        5641  +
    fun test306() = runTest {
 5698   5642   
        val params = DynamoDbEndpointParameters {
 5699   5643   
            useFips = false
 5700   5644   
            useDualStack = false
 5701   5645   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 5702   5646   
            accountIdEndpointMode = "preferred"
 5703   5647   
            region = "cn-north-1"
 5704   5648   
        }
 5705   5649   
        val expected = Endpoint(
 5706   5650   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5707   5651   
        )
 5708   5652   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5709   5653   
        expectEqualEndpoints(expected, actual)
 5710   5654   
    }
 5711   5655   
 5712   5656   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=preferred, Region=cn-north-1}
 5713   5657   
    @Test
 5714         -
    fun test311() = runTest {
        5658  +
    fun test307() = runTest {
 5715   5659   
        val params = DynamoDbEndpointParameters {
 5716   5660   
            useFips = false
 5717   5661   
            useDualStack = false
 5718   5662   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 5719   5663   
            accountIdEndpointMode = "preferred"
 5720   5664   
            region = "cn-north-1"
 5721   5665   
        }
 5722   5666   
        val expected = Endpoint(
 5723   5667   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5724   5668   
        )
 5725   5669   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5726   5670   
        expectEqualEndpoints(expected, actual)
 5727   5671   
    }
 5728   5672   
 5729   5673   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=preferred, Region=cn-north-1}
 5730   5674   
    @Test
 5731         -
    fun test312() = runTest {
        5675  +
    fun test308() = runTest {
 5732   5676   
        val params = DynamoDbEndpointParameters {
 5733   5677   
            useFips = false
 5734   5678   
            useDualStack = false
 5735   5679   
            resourceArn = ""
 5736   5680   
            accountIdEndpointMode = "preferred"
 5737   5681   
            region = "cn-north-1"
 5738   5682   
        }
 5739   5683   
        val expected = Endpoint(
 5740   5684   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5741   5685   
        )
 5742   5686   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5743   5687   
        expectEqualEndpoints(expected, actual)
 5744   5688   
    }
 5745   5689   
 5746   5690   
    // {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=cn-north-1}
 5747   5691   
    @Test
 5748         -
    fun test313() = runTest {
        5692  +
    fun test309() = runTest {
 5749   5693   
        val params = DynamoDbEndpointParameters {
 5750   5694   
            useFips = true
 5751   5695   
            useDualStack = true
 5752   5696   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5753   5697   
            accountIdEndpointMode = "preferred"
 5754   5698   
            region = "cn-north-1"
 5755   5699   
        }
 5756   5700   
        val expected = Endpoint(
 5757   5701   
            uri = Url.parse("https://dynamodb-fips.cn-north-1.api.amazonwebservices.com.cn"),
 5758   5702   
        )
 5759   5703   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5760   5704   
        expectEqualEndpoints(expected, actual)
 5761   5705   
    }
 5762   5706   
 5763   5707   
    // {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=cn-north-1}
 5764   5708   
    @Test
 5765         -
    fun test314() = runTest {
        5709  +
    fun test310() = runTest {
 5766   5710   
        val params = DynamoDbEndpointParameters {
 5767   5711   
            useFips = true
 5768   5712   
            useDualStack = false
 5769   5713   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5770   5714   
            accountIdEndpointMode = "preferred"
 5771   5715   
            region = "cn-north-1"
 5772   5716   
        }
 5773   5717   
        val expected = Endpoint(
 5774   5718   
            uri = Url.parse("https://dynamodb-fips.cn-north-1.amazonaws.com.cn"),
 5775   5719   
        )
 5776   5720   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5777   5721   
        expectEqualEndpoints(expected, actual)
 5778   5722   
    }
 5779   5723   
 5780   5724   
    // {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=cn-north-1}
 5781   5725   
    @Test
 5782         -
    fun test315() = runTest {
        5726  +
    fun test311() = runTest {
 5783   5727   
        val params = DynamoDbEndpointParameters {
 5784   5728   
            useFips = false
 5785   5729   
            useDualStack = true
 5786   5730   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5787   5731   
            accountIdEndpointMode = "preferred"
 5788   5732   
            region = "cn-north-1"
 5789   5733   
        }
 5790   5734   
        val expected = Endpoint(
 5791   5735   
            uri = Url.parse("https://dynamodb.cn-north-1.api.amazonwebservices.com.cn"),
 5792   5736   
        )
 5793   5737   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5794   5738   
        expectEqualEndpoints(expected, actual)
 5795   5739   
    }
 5796   5740   
 5797   5741   
    // {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=cn-north-1}
 5798   5742   
    @Test
 5799         -
    fun test316() = runTest {
        5743  +
    fun test312() = runTest {
 5800   5744   
        val params = DynamoDbEndpointParameters {
 5801   5745   
            useFips = false
 5802   5746   
            useDualStack = false
 5803   5747   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5804   5748   
            accountIdEndpointMode = "preferred"
 5805   5749   
            region = "cn-north-1"
 5806   5750   
        }
 5807   5751   
        val expected = Endpoint(
 5808   5752   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5809   5753   
        )
 5810   5754   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5811   5755   
        expectEqualEndpoints(expected, actual)
 5812   5756   
    }
 5813   5757   
 5814   5758   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=cn-north-1}
 5815   5759   
    @Test
 5816         -
    fun test317() = runTest {
        5760  +
    fun test313() = runTest {
 5817   5761   
        val params = DynamoDbEndpointParameters {
 5818   5762   
            useFips = false
 5819   5763   
            useDualStack = false
 5820   5764   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 5821   5765   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5822   5766   
            accountIdEndpointMode = "preferred"
 5823   5767   
            region = "cn-north-1"
 5824   5768   
        }
 5825   5769   
        val expected = Endpoint(
 5826   5770   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5827   5771   
        )
 5828   5772   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5829   5773   
        expectEqualEndpoints(expected, actual)
 5830   5774   
    }
 5831   5775   
 5832   5776   
    // {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=preferred, Region=cn-north-1}
 5833   5777   
    @Test
 5834         -
    fun test318() = runTest {
        5778  +
    fun test314() = runTest {
 5835   5779   
        val params = DynamoDbEndpointParameters {
 5836   5780   
            useFips = false
 5837   5781   
            useDualStack = false
 5838   5782   
            accountIdEndpointMode = "preferred"
 5839   5783   
            region = "cn-north-1"
 5840   5784   
        }
 5841   5785   
        val expected = Endpoint(
 5842   5786   
            uri = Url.parse("https://dynamodb.cn-north-1.amazonaws.com.cn"),
 5843   5787   
        )
 5844   5788   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5845   5789   
        expectEqualEndpoints(expected, actual)
 5846   5790   
    }
 5847   5791   
 5848         -
    // {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 5849         -
    @Test
 5850         -
    fun test319() = runTest {
 5851         -
        val params = DynamoDbEndpointParameters {
 5852         -
            useFips = true
 5853         -
            useDualStack = true
 5854         -
            accountId = "111111111111"
 5855         -
            accountIdEndpointMode = "preferred"
 5856         -
            region = "us-iso-east-1"
 5857         -
        }
 5858         -
        val ex = assertFailsWith<EndpointProviderException> {
 5859         -
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5860         -
        }
 5861         -
        assertEquals("FIPS and DualStack are enabled, but this partition does not support one or both", ex.message)
 5862         -
    }
 5863         -
 5864   5792   
    // {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 5865   5793   
    @Test
 5866         -
    fun test320() = runTest {
        5794  +
    fun test315() = runTest {
 5867   5795   
        val params = DynamoDbEndpointParameters {
 5868   5796   
            useFips = true
 5869   5797   
            useDualStack = false
 5870   5798   
            accountId = "111111111111"
 5871   5799   
            accountIdEndpointMode = "preferred"
 5872   5800   
            region = "us-iso-east-1"
 5873   5801   
        }
 5874   5802   
        val expected = Endpoint(
 5875   5803   
            uri = Url.parse("https://dynamodb-fips.us-iso-east-1.c2s.ic.gov"),
 5876   5804   
        )
 5877   5805   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5878   5806   
        expectEqualEndpoints(expected, actual)
 5879   5807   
    }
 5880   5808   
 5881         -
    // {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 5882         -
    @Test
 5883         -
    fun test321() = runTest {
 5884         -
        val params = DynamoDbEndpointParameters {
 5885         -
            useFips = false
 5886         -
            useDualStack = true
 5887         -
            accountId = "111111111111"
 5888         -
            accountIdEndpointMode = "preferred"
 5889         -
            region = "us-iso-east-1"
 5890         -
        }
 5891         -
        val ex = assertFailsWith<EndpointProviderException> {
 5892         -
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5893         -
        }
 5894         -
        assertEquals("DualStack is enabled but this partition does not support DualStack", ex.message)
 5895         -
    }
 5896         -
 5897   5809   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 5898   5810   
    @Test
 5899         -
    fun test322() = runTest {
        5811  +
    fun test316() = runTest {
 5900   5812   
        val params = DynamoDbEndpointParameters {
 5901   5813   
            useFips = false
 5902   5814   
            useDualStack = false
 5903   5815   
            accountId = "111111111111"
 5904   5816   
            accountIdEndpointMode = "preferred"
 5905   5817   
            region = "us-iso-east-1"
 5906   5818   
        }
 5907   5819   
        val expected = Endpoint(
 5908   5820   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 5909   5821   
        )
 5910   5822   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5911   5823   
        expectEqualEndpoints(expected, actual)
 5912   5824   
    }
 5913   5825   
 5914   5826   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 5915   5827   
    @Test
 5916         -
    fun test323() = runTest {
        5828  +
    fun test317() = runTest {
 5917   5829   
        val params = DynamoDbEndpointParameters {
 5918   5830   
            useFips = false
 5919   5831   
            useDualStack = false
 5920   5832   
            accountId = "111111111111"
 5921   5833   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5922   5834   
            accountIdEndpointMode = "preferred"
 5923   5835   
            region = "us-iso-east-1"
 5924   5836   
        }
 5925   5837   
        val expected = Endpoint(
 5926   5838   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 5927   5839   
        )
 5928   5840   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5929   5841   
        expectEqualEndpoints(expected, actual)
 5930   5842   
    }
 5931   5843   
 5932   5844   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 5933   5845   
    @Test
 5934         -
    fun test324() = runTest {
        5846  +
    fun test318() = runTest {
 5935   5847   
        val params = DynamoDbEndpointParameters {
 5936   5848   
            useFips = false
 5937   5849   
            useDualStack = false
 5938   5850   
            accountId = "111111111111"
 5939   5851   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 5940   5852   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5941   5853   
            accountIdEndpointMode = "preferred"
 5942   5854   
            region = "us-iso-east-1"
 5943   5855   
        }
 5944   5856   
        val expected = Endpoint(
 5945   5857   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 5946   5858   
        )
 5947   5859   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5948   5860   
        expectEqualEndpoints(expected, actual)
 5949   5861   
    }
 5950   5862   
 5951   5863   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 5952   5864   
    @Test
 5953         -
    fun test325() = runTest {
        5865  +
    fun test319() = runTest {
 5954   5866   
        val params = DynamoDbEndpointParameters {
 5955   5867   
            useFips = false
 5956   5868   
            useDualStack = false
 5957   5869   
            accountId = "111111111111"
 5958   5870   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 5959   5871   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5960   5872   
            accountIdEndpointMode = "preferred"
 5961   5873   
            region = "us-iso-east-1"
 5962   5874   
        }
 5963   5875   
        val expected = Endpoint(
 5964   5876   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 5965   5877   
        )
 5966   5878   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5967   5879   
        expectEqualEndpoints(expected, actual)
 5968   5880   
    }
 5969   5881   
 5970   5882   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 5971   5883   
    @Test
 5972         -
    fun test326() = runTest {
        5884  +
    fun test320() = runTest {
 5973   5885   
        val params = DynamoDbEndpointParameters {
 5974   5886   
            useFips = false
 5975   5887   
            useDualStack = false
 5976   5888   
            accountId = "111111111111"
 5977   5889   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 5978   5890   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 5979   5891   
            accountIdEndpointMode = "preferred"
 5980   5892   
            region = "us-iso-east-1"
 5981   5893   
        }
 5982   5894   
        val expected = Endpoint(
 5983   5895   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 5984   5896   
        )
 5985   5897   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 5986   5898   
        expectEqualEndpoints(expected, actual)
 5987   5899   
    }
 5988   5900   
 5989   5901   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 5990   5902   
    @Test
 5991         -
    fun test327() = runTest {
        5903  +
    fun test321() = runTest {
 5992   5904   
        val params = DynamoDbEndpointParameters {
 5993   5905   
            useFips = false
 5994   5906   
            useDualStack = false
 5995   5907   
            accountId = "111111111111"
 5996   5908   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 5997   5909   
            resourceArnList = listOf("arn:aws:dynamodb:us-west-2:333333333333:table/table_name")
 5998   5910   
            accountIdEndpointMode = "preferred"
 5999   5911   
            region = "us-iso-east-1"
 6000   5912   
        }
 6001   5913   
        val expected = Endpoint(
 6002   5914   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 6003   5915   
        )
 6004   5916   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6005   5917   
        expectEqualEndpoints(expected, actual)
 6006   5918   
    }
 6007   5919   
 6008   5920   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6009   5921   
    @Test
 6010         -
    fun test328() = runTest {
        5922  +
    fun test322() = runTest {
 6011   5923   
        val params = DynamoDbEndpointParameters {
 6012   5924   
            useFips = false
 6013   5925   
            useDualStack = false
 6014   5926   
            accountId = "111111111111"
 6015   5927   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 6016   5928   
            resourceArnList = listOf("arn:aws:s3:us-east-1:333333333333:stream/testStream")
 6017   5929   
            accountIdEndpointMode = "preferred"
 6018   5930   
            region = "us-iso-east-1"
 6019   5931   
        }
 6020   5932   
        val expected = Endpoint(
 6021   5933   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 6022   5934   
        )
 6023   5935   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6024   5936   
        expectEqualEndpoints(expected, actual)
 6025   5937   
    }
 6026   5938   
 6027   5939   
    // {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6028   5940   
    @Test
 6029         -
    fun test329() = runTest {
        5941  +
    fun test323() = runTest {
 6030   5942   
        val params = DynamoDbEndpointParameters {
 6031   5943   
            useFips = false
 6032   5944   
            useDualStack = false
 6033   5945   
            accountId = ""
 6034   5946   
            accountIdEndpointMode = "preferred"
 6035   5947   
            region = "us-iso-east-1"
 6036   5948   
        }
 6037   5949   
        val expected = Endpoint(
 6038   5950   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 6039   5951   
        )
 6040   5952   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6041   5953   
        expectEqualEndpoints(expected, actual)
 6042   5954   
    }
 6043   5955   
 6044         -
    // {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6045         -
    @Test
 6046         -
    fun test330() = runTest {
 6047         -
        val params = DynamoDbEndpointParameters {
 6048         -
            useFips = true
 6049         -
            useDualStack = true
 6050         -
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 6051         -
            accountIdEndpointMode = "preferred"
 6052         -
            region = "us-iso-east-1"
 6053         -
        }
 6054         -
        val ex = assertFailsWith<EndpointProviderException> {
 6055         -
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6056         -
        }
 6057         -
        assertEquals("FIPS and DualStack are enabled, but this partition does not support one or both", ex.message)
 6058         -
    }
 6059         -
 6060   5956   
    // {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6061   5957   
    @Test
 6062         -
    fun test331() = runTest {
        5958  +
    fun test324() = runTest {
 6063   5959   
        val params = DynamoDbEndpointParameters {
 6064   5960   
            useFips = true
 6065   5961   
            useDualStack = false
 6066   5962   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 6067   5963   
            accountIdEndpointMode = "preferred"
 6068   5964   
            region = "us-iso-east-1"
 6069   5965   
        }
 6070   5966   
        val expected = Endpoint(
 6071   5967   
            uri = Url.parse("https://dynamodb-fips.us-iso-east-1.c2s.ic.gov"),
 6072   5968   
        )
 6073   5969   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6074   5970   
        expectEqualEndpoints(expected, actual)
 6075   5971   
    }
 6076   5972   
 6077         -
    // {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6078         -
    @Test
 6079         -
    fun test332() = runTest {
 6080         -
        val params = DynamoDbEndpointParameters {
 6081         -
            useFips = false
 6082         -
            useDualStack = true
 6083         -
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 6084         -
            accountIdEndpointMode = "preferred"
 6085         -
            region = "us-iso-east-1"
 6086         -
        }
 6087         -
        val ex = assertFailsWith<EndpointProviderException> {
 6088         -
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6089         -
        }
 6090         -
        assertEquals("DualStack is enabled but this partition does not support DualStack", ex.message)
 6091         -
    }
 6092         -
 6093   5973   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6094   5974   
    @Test
 6095         -
    fun test333() = runTest {
        5975  +
    fun test325() = runTest {
 6096   5976   
        val params = DynamoDbEndpointParameters {
 6097   5977   
            useFips = false
 6098   5978   
            useDualStack = false
 6099   5979   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 6100   5980   
            accountIdEndpointMode = "preferred"
 6101   5981   
            region = "us-iso-east-1"
 6102   5982   
        }
 6103   5983   
        val expected = Endpoint(
 6104   5984   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 6105   5985   
        )
 6106   5986   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6107   5987   
        expectEqualEndpoints(expected, actual)
 6108   5988   
    }
 6109   5989   
 6110   5990   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6111   5991   
    @Test
 6112         -
    fun test334() = runTest {
        5992  +
    fun test326() = runTest {
 6113   5993   
        val params = DynamoDbEndpointParameters {
 6114   5994   
            useFips = false
 6115   5995   
            useDualStack = false
 6116   5996   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 6117   5997   
            accountIdEndpointMode = "preferred"
 6118   5998   
            region = "us-iso-east-1"
 6119   5999   
        }
 6120   6000   
        val expected = Endpoint(
 6121   6001   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 6122   6002   
        )
 6123   6003   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6124   6004   
        expectEqualEndpoints(expected, actual)
 6125   6005   
    }
 6126   6006   
 6127   6007   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6128   6008   
    @Test
 6129         -
    fun test335() = runTest {
        6009  +
    fun test327() = runTest {
 6130   6010   
        val params = DynamoDbEndpointParameters {
 6131   6011   
            useFips = false
 6132   6012   
            useDualStack = false
 6133   6013   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 6134   6014   
            accountIdEndpointMode = "preferred"
 6135   6015   
            region = "us-iso-east-1"
 6136   6016   
        }
 6137   6017   
        val expected = Endpoint(
 6138   6018   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 6139   6019   
        )
 6140   6020   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6141   6021   
        expectEqualEndpoints(expected, actual)
 6142   6022   
    }
 6143   6023   
 6144   6024   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6145   6025   
    @Test
 6146         -
    fun test336() = runTest {
        6026  +
    fun test328() = runTest {
 6147   6027   
        val params = DynamoDbEndpointParameters {
 6148   6028   
            useFips = false
 6149   6029   
            useDualStack = false
 6150   6030   
            resourceArn = ""
 6151   6031   
            accountIdEndpointMode = "preferred"
 6152   6032   
            region = "us-iso-east-1"
 6153   6033   
        }
 6154   6034   
        val expected = Endpoint(
 6155   6035   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 6156   6036   
        )
 6157   6037   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6158   6038   
        expectEqualEndpoints(expected, actual)
 6159   6039   
    }
 6160   6040   
 6161         -
    // {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6162         -
    @Test
 6163         -
    fun test337() = runTest {
 6164         -
        val params = DynamoDbEndpointParameters {
 6165         -
            useFips = true
 6166         -
            useDualStack = true
 6167         -
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 6168         -
            accountIdEndpointMode = "preferred"
 6169         -
            region = "us-iso-east-1"
 6170         -
        }
 6171         -
        val ex = assertFailsWith<EndpointProviderException> {
 6172         -
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6173         -
        }
 6174         -
        assertEquals("FIPS and DualStack are enabled, but this partition does not support one or both", ex.message)
 6175         -
    }
 6176         -
 6177   6041   
    // {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6178   6042   
    @Test
 6179         -
    fun test338() = runTest {
        6043  +
    fun test329() = runTest {
 6180   6044   
        val params = DynamoDbEndpointParameters {
 6181   6045   
            useFips = true
 6182   6046   
            useDualStack = false
 6183   6047   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 6184   6048   
            accountIdEndpointMode = "preferred"
 6185   6049   
            region = "us-iso-east-1"
 6186   6050   
        }
 6187   6051   
        val expected = Endpoint(
 6188   6052   
            uri = Url.parse("https://dynamodb-fips.us-iso-east-1.c2s.ic.gov"),
 6189   6053   
        )
 6190   6054   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6191   6055   
        expectEqualEndpoints(expected, actual)
 6192   6056   
    }
 6193   6057   
 6194         -
    // {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6195         -
    @Test
 6196         -
    fun test339() = runTest {
 6197         -
        val params = DynamoDbEndpointParameters {
 6198         -
            useFips = false
 6199         -
            useDualStack = true
 6200         -
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 6201         -
            accountIdEndpointMode = "preferred"
 6202         -
            region = "us-iso-east-1"
 6203         -
        }
 6204         -
        val ex = assertFailsWith<EndpointProviderException> {
 6205         -
            DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6206         -
        }
 6207         -
        assertEquals("DualStack is enabled but this partition does not support DualStack", ex.message)
 6208         -
    }
 6209         -
 6210   6058   
    // {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6211   6059   
    @Test
 6212         -
    fun test340() = runTest {
        6060  +
    fun test330() = runTest {
 6213   6061   
        val params = DynamoDbEndpointParameters {
 6214   6062   
            useFips = false
 6215   6063   
            useDualStack = false
 6216   6064   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 6217   6065   
            accountIdEndpointMode = "preferred"
 6218   6066   
            region = "us-iso-east-1"
 6219   6067   
        }
 6220   6068   
        val expected = Endpoint(
 6221   6069   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 6222   6070   
        )
 6223   6071   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6224   6072   
        expectEqualEndpoints(expected, actual)
 6225   6073   
    }
 6226   6074   
 6227   6075   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6228   6076   
    @Test
 6229         -
    fun test341() = runTest {
        6077  +
    fun test331() = runTest {
 6230   6078   
        val params = DynamoDbEndpointParameters {
 6231   6079   
            useFips = false
 6232   6080   
            useDualStack = false
 6233   6081   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 6234   6082   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 6235   6083   
            accountIdEndpointMode = "preferred"
 6236   6084   
            region = "us-iso-east-1"
 6237   6085   
        }
 6238   6086   
        val expected = Endpoint(
 6239   6087   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 6240   6088   
        )
 6241   6089   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6242   6090   
        expectEqualEndpoints(expected, actual)
 6243   6091   
    }
 6244   6092   
 6245   6093   
    // {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=preferred, Region=us-iso-east-1}
 6246   6094   
    @Test
 6247         -
    fun test342() = runTest {
        6095  +
    fun test332() = runTest {
 6248   6096   
        val params = DynamoDbEndpointParameters {
 6249   6097   
            useFips = false
 6250   6098   
            useDualStack = false
 6251   6099   
            accountIdEndpointMode = "preferred"
 6252   6100   
            region = "us-iso-east-1"
 6253   6101   
        }
 6254   6102   
        val expected = Endpoint(
 6255   6103   
            uri = Url.parse("https://dynamodb.us-iso-east-1.c2s.ic.gov"),
 6256   6104   
        )
 6257   6105   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6258   6106   
        expectEqualEndpoints(expected, actual)
 6259   6107   
    }
 6260   6108   
 6261   6109   
    // {UseFIPS=true, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6262   6110   
    @Test
 6263         -
    fun test343() = runTest {
        6111  +
    fun test333() = runTest {
 6264   6112   
        val params = DynamoDbEndpointParameters {
 6265   6113   
            useFips = true
 6266   6114   
            useDualStack = true
 6267   6115   
            accountId = "111111111111"
 6268   6116   
            accountIdEndpointMode = "preferred"
 6269   6117   
            region = "us-gov-east-1"
 6270   6118   
        }
 6271   6119   
        val expected = Endpoint(
 6272   6120   
            uri = Url.parse("https://dynamodb-fips.us-gov-east-1.api.aws"),
 6273   6121   
        )
 6274   6122   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6275   6123   
        expectEqualEndpoints(expected, actual)
 6276   6124   
    }
 6277   6125   
 6278   6126   
    // {UseFIPS=true, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6279   6127   
    @Test
 6280         -
    fun test344() = runTest {
        6128  +
    fun test334() = runTest {
 6281   6129   
        val params = DynamoDbEndpointParameters {
 6282   6130   
            useFips = true
 6283   6131   
            useDualStack = false
 6284   6132   
            accountId = "111111111111"
 6285   6133   
            accountIdEndpointMode = "preferred"
 6286   6134   
            region = "us-gov-east-1"
 6287   6135   
        }
 6288   6136   
        val expected = Endpoint(
 6289   6137   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6290   6138   
        )
 6291   6139   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6292   6140   
        expectEqualEndpoints(expected, actual)
 6293   6141   
    }
 6294   6142   
 6295   6143   
    // {UseFIPS=false, UseDualStack=true, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6296   6144   
    @Test
 6297         -
    fun test345() = runTest {
        6145  +
    fun test335() = runTest {
 6298   6146   
        val params = DynamoDbEndpointParameters {
 6299   6147   
            useFips = false
 6300   6148   
            useDualStack = true
 6301   6149   
            accountId = "111111111111"
 6302   6150   
            accountIdEndpointMode = "preferred"
 6303   6151   
            region = "us-gov-east-1"
 6304   6152   
        }
 6305   6153   
        val expected = Endpoint(
 6306   6154   
            uri = Url.parse("https://dynamodb.us-gov-east-1.api.aws"),
 6307   6155   
        )
 6308   6156   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6309   6157   
        expectEqualEndpoints(expected, actual)
 6310   6158   
    }
 6311   6159   
 6312   6160   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6313   6161   
    @Test
 6314         -
    fun test346() = runTest {
        6162  +
    fun test336() = runTest {
 6315   6163   
        val params = DynamoDbEndpointParameters {
 6316   6164   
            useFips = false
 6317   6165   
            useDualStack = false
 6318   6166   
            accountId = "111111111111"
 6319   6167   
            accountIdEndpointMode = "preferred"
 6320   6168   
            region = "us-gov-east-1"
 6321   6169   
        }
 6322   6170   
        val expected = Endpoint(
 6323   6171   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6324   6172   
        )
 6325   6173   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6326   6174   
        expectEqualEndpoints(expected, actual)
 6327   6175   
    }
 6328   6176   
 6329   6177   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6330   6178   
    @Test
 6331         -
    fun test347() = runTest {
        6179  +
    fun test337() = runTest {
 6332   6180   
        val params = DynamoDbEndpointParameters {
 6333   6181   
            useFips = false
 6334   6182   
            useDualStack = false
 6335   6183   
            accountId = "111111111111"
 6336   6184   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 6337   6185   
            accountIdEndpointMode = "preferred"
 6338   6186   
            region = "us-gov-east-1"
 6339   6187   
        }
 6340   6188   
        val expected = Endpoint(
 6341   6189   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6342   6190   
        )
 6343   6191   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6344   6192   
        expectEqualEndpoints(expected, actual)
 6345   6193   
    }
 6346   6194   
 6347   6195   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6348   6196   
    @Test
 6349         -
    fun test348() = runTest {
        6197  +
    fun test338() = runTest {
 6350   6198   
        val params = DynamoDbEndpointParameters {
 6351   6199   
            useFips = false
 6352   6200   
            useDualStack = false
 6353   6201   
            accountId = "111111111111"
 6354   6202   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 6355   6203   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 6356   6204   
            accountIdEndpointMode = "preferred"
 6357   6205   
            region = "us-gov-east-1"
 6358   6206   
        }
 6359   6207   
        val expected = Endpoint(
 6360   6208   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6361   6209   
        )
 6362   6210   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6363   6211   
        expectEqualEndpoints(expected, actual)
 6364   6212   
    }
 6365   6213   
 6366   6214   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6367   6215   
    @Test
 6368         -
    fun test349() = runTest {
        6216  +
    fun test339() = runTest {
 6369   6217   
        val params = DynamoDbEndpointParameters {
 6370   6218   
            useFips = false
 6371   6219   
            useDualStack = false
 6372   6220   
            accountId = "111111111111"
 6373   6221   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 6374   6222   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 6375   6223   
            accountIdEndpointMode = "preferred"
 6376   6224   
            region = "us-gov-east-1"
 6377   6225   
        }
 6378   6226   
        val expected = Endpoint(
 6379   6227   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6380   6228   
        )
 6381   6229   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6382   6230   
        expectEqualEndpoints(expected, actual)
 6383   6231   
    }
 6384   6232   
 6385   6233   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6386   6234   
    @Test
 6387         -
    fun test350() = runTest {
        6235  +
    fun test340() = runTest {
 6388   6236   
        val params = DynamoDbEndpointParameters {
 6389   6237   
            useFips = false
 6390   6238   
            useDualStack = false
 6391   6239   
            accountId = "111111111111"
 6392   6240   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 6393   6241   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 6394   6242   
            accountIdEndpointMode = "preferred"
 6395   6243   
            region = "us-gov-east-1"
 6396   6244   
        }
 6397   6245   
        val expected = Endpoint(
 6398   6246   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6399   6247   
        )
 6400   6248   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6401   6249   
        expectEqualEndpoints(expected, actual)
 6402   6250   
    }
 6403   6251   
 6404   6252   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-west-2:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6405   6253   
    @Test
 6406         -
    fun test351() = runTest {
        6254  +
    fun test341() = runTest {
 6407   6255   
        val params = DynamoDbEndpointParameters {
 6408   6256   
            useFips = false
 6409   6257   
            useDualStack = false
 6410   6258   
            accountId = "111111111111"
 6411   6259   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 6412   6260   
            resourceArnList = listOf("arn:aws:dynamodb:us-west-2:333333333333:table/table_name")
 6413   6261   
            accountIdEndpointMode = "preferred"
 6414   6262   
            region = "us-gov-east-1"
 6415   6263   
        }
 6416   6264   
        val expected = Endpoint(
 6417   6265   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6418   6266   
        )
 6419   6267   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6420   6268   
        expectEqualEndpoints(expected, actual)
 6421   6269   
    }
 6422   6270   
 6423   6271   
    // {UseFIPS=false, UseDualStack=false, AccountId=111111111111, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, ResourceArnList=[arn:aws:s3:us-east-1:333333333333:stream/testStream], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6424   6272   
    @Test
 6425         -
    fun test352() = runTest {
        6273  +
    fun test342() = runTest {
 6426   6274   
        val params = DynamoDbEndpointParameters {
 6427   6275   
            useFips = false
 6428   6276   
            useDualStack = false
 6429   6277   
            accountId = "111111111111"
 6430   6278   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 6431   6279   
            resourceArnList = listOf("arn:aws:s3:us-east-1:333333333333:stream/testStream")
 6432   6280   
            accountIdEndpointMode = "preferred"
 6433   6281   
            region = "us-gov-east-1"
 6434   6282   
        }
 6435   6283   
        val expected = Endpoint(
 6436   6284   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6437   6285   
        )
 6438   6286   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6439   6287   
        expectEqualEndpoints(expected, actual)
 6440   6288   
    }
 6441   6289   
 6442   6290   
    // {UseFIPS=false, UseDualStack=false, AccountId=, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6443   6291   
    @Test
 6444         -
    fun test353() = runTest {
        6292  +
    fun test343() = runTest {
 6445   6293   
        val params = DynamoDbEndpointParameters {
 6446   6294   
            useFips = false
 6447   6295   
            useDualStack = false
 6448   6296   
            accountId = ""
 6449   6297   
            accountIdEndpointMode = "preferred"
 6450   6298   
            region = "us-gov-east-1"
 6451   6299   
        }
 6452   6300   
        val expected = Endpoint(
 6453   6301   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6454   6302   
        )
 6455   6303   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6456   6304   
        expectEqualEndpoints(expected, actual)
 6457   6305   
    }
 6458   6306   
 6459   6307   
    // {UseFIPS=true, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6460   6308   
    @Test
 6461         -
    fun test354() = runTest {
        6309  +
    fun test344() = runTest {
 6462   6310   
        val params = DynamoDbEndpointParameters {
 6463   6311   
            useFips = true
 6464   6312   
            useDualStack = true
 6465   6313   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 6466   6314   
            accountIdEndpointMode = "preferred"
 6467   6315   
            region = "us-gov-east-1"
 6468   6316   
        }
 6469   6317   
        val expected = Endpoint(
 6470   6318   
            uri = Url.parse("https://dynamodb-fips.us-gov-east-1.api.aws"),
 6471   6319   
        )
 6472   6320   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6473   6321   
        expectEqualEndpoints(expected, actual)
 6474   6322   
    }
 6475   6323   
 6476   6324   
    // {UseFIPS=true, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6477   6325   
    @Test
 6478         -
    fun test355() = runTest {
        6326  +
    fun test345() = runTest {
 6479   6327   
        val params = DynamoDbEndpointParameters {
 6480   6328   
            useFips = true
 6481   6329   
            useDualStack = false
 6482   6330   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 6483   6331   
            accountIdEndpointMode = "preferred"
 6484   6332   
            region = "us-gov-east-1"
 6485   6333   
        }
 6486   6334   
        val expected = Endpoint(
 6487   6335   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6488   6336   
        )
 6489   6337   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6490   6338   
        expectEqualEndpoints(expected, actual)
 6491   6339   
    }
 6492   6340   
 6493   6341   
    // {UseFIPS=false, UseDualStack=true, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6494   6342   
    @Test
 6495         -
    fun test356() = runTest {
        6343  +
    fun test346() = runTest {
 6496   6344   
        val params = DynamoDbEndpointParameters {
 6497   6345   
            useFips = false
 6498   6346   
            useDualStack = true
 6499   6347   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 6500   6348   
            accountIdEndpointMode = "preferred"
 6501   6349   
            region = "us-gov-east-1"
 6502   6350   
        }
 6503   6351   
        val expected = Endpoint(
 6504   6352   
            uri = Url.parse("https://dynamodb.us-gov-east-1.api.aws"),
 6505   6353   
        )
 6506   6354   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6507   6355   
        expectEqualEndpoints(expected, actual)
 6508   6356   
    }
 6509   6357   
 6510   6358   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6511   6359   
    @Test
 6512         -
    fun test357() = runTest {
        6360  +
    fun test347() = runTest {
 6513   6361   
        val params = DynamoDbEndpointParameters {
 6514   6362   
            useFips = false
 6515   6363   
            useDualStack = false
 6516   6364   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 6517   6365   
            accountIdEndpointMode = "preferred"
 6518   6366   
            region = "us-gov-east-1"
 6519   6367   
        }
 6520   6368   
        val expected = Endpoint(
 6521   6369   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6522   6370   
        )
 6523   6371   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6524   6372   
        expectEqualEndpoints(expected, actual)
 6525   6373   
    }
 6526   6374   
 6527   6375   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-west-2:222222222222:table/table_name, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6528   6376   
    @Test
 6529         -
    fun test358() = runTest {
        6377  +
    fun test348() = runTest {
 6530   6378   
        val params = DynamoDbEndpointParameters {
 6531   6379   
            useFips = false
 6532   6380   
            useDualStack = false
 6533   6381   
            resourceArn = "arn:aws:dynamodb:us-west-2:222222222222:table/table_name"
 6534   6382   
            accountIdEndpointMode = "preferred"
 6535   6383   
            region = "us-gov-east-1"
 6536   6384   
        }
 6537   6385   
        val expected = Endpoint(
 6538   6386   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6539   6387   
        )
 6540   6388   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6541   6389   
        expectEqualEndpoints(expected, actual)
 6542   6390   
    }
 6543   6391   
 6544   6392   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:s3:us-west-2:222222222222:stream/testStream, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6545   6393   
    @Test
 6546         -
    fun test359() = runTest {
        6394  +
    fun test349() = runTest {
 6547   6395   
        val params = DynamoDbEndpointParameters {
 6548   6396   
            useFips = false
 6549   6397   
            useDualStack = false
 6550   6398   
            resourceArn = "arn:aws:s3:us-west-2:222222222222:stream/testStream"
 6551   6399   
            accountIdEndpointMode = "preferred"
 6552   6400   
            region = "us-gov-east-1"
 6553   6401   
        }
 6554   6402   
        val expected = Endpoint(
 6555   6403   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6556   6404   
        )
 6557   6405   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6558   6406   
        expectEqualEndpoints(expected, actual)
 6559   6407   
    }
 6560   6408   
 6561   6409   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6562   6410   
    @Test
 6563         -
    fun test360() = runTest {
        6411  +
    fun test350() = runTest {
 6564   6412   
        val params = DynamoDbEndpointParameters {
 6565   6413   
            useFips = false
 6566   6414   
            useDualStack = false
 6567   6415   
            resourceArn = ""
 6568   6416   
            accountIdEndpointMode = "preferred"
 6569   6417   
            region = "us-gov-east-1"
 6570   6418   
        }
 6571   6419   
        val expected = Endpoint(
 6572   6420   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6573   6421   
        )
 6574   6422   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6575   6423   
        expectEqualEndpoints(expected, actual)
 6576   6424   
    }
 6577   6425   
 6578   6426   
    // {UseFIPS=true, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6579   6427   
    @Test
 6580         -
    fun test361() = runTest {
        6428  +
    fun test351() = runTest {
 6581   6429   
        val params = DynamoDbEndpointParameters {
 6582   6430   
            useFips = true
 6583   6431   
            useDualStack = true
 6584   6432   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 6585   6433   
            accountIdEndpointMode = "preferred"
 6586   6434   
            region = "us-gov-east-1"
 6587   6435   
        }
 6588   6436   
        val expected = Endpoint(
 6589   6437   
            uri = Url.parse("https://dynamodb-fips.us-gov-east-1.api.aws"),
 6590   6438   
        )
 6591   6439   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6592   6440   
        expectEqualEndpoints(expected, actual)
 6593   6441   
    }
 6594   6442   
 6595   6443   
    // {UseFIPS=true, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6596   6444   
    @Test
 6597         -
    fun test362() = runTest {
        6445  +
    fun test352() = runTest {
 6598   6446   
        val params = DynamoDbEndpointParameters {
 6599   6447   
            useFips = true
 6600   6448   
            useDualStack = false
 6601   6449   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 6602   6450   
            accountIdEndpointMode = "preferred"
 6603   6451   
            region = "us-gov-east-1"
 6604   6452   
        }
 6605   6453   
        val expected = Endpoint(
 6606   6454   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6607   6455   
        )
 6608   6456   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6609   6457   
        expectEqualEndpoints(expected, actual)
 6610   6458   
    }
 6611   6459   
 6612   6460   
    // {UseFIPS=false, UseDualStack=true, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6613   6461   
    @Test
 6614         -
    fun test363() = runTest {
        6462  +
    fun test353() = runTest {
 6615   6463   
        val params = DynamoDbEndpointParameters {
 6616   6464   
            useFips = false
 6617   6465   
            useDualStack = true
 6618   6466   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 6619   6467   
            accountIdEndpointMode = "preferred"
 6620   6468   
            region = "us-gov-east-1"
 6621   6469   
        }
 6622   6470   
        val expected = Endpoint(
 6623   6471   
            uri = Url.parse("https://dynamodb.us-gov-east-1.api.aws"),
 6624   6472   
        )
 6625   6473   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6626   6474   
        expectEqualEndpoints(expected, actual)
 6627   6475   
    }
 6628   6476   
 6629   6477   
    // {UseFIPS=false, UseDualStack=false, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6630   6478   
    @Test
 6631         -
    fun test364() = runTest {
        6479  +
    fun test354() = runTest {
 6632   6480   
        val params = DynamoDbEndpointParameters {
 6633   6481   
            useFips = false
 6634   6482   
            useDualStack = false
 6635   6483   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 6636   6484   
            accountIdEndpointMode = "preferred"
 6637   6485   
            region = "us-gov-east-1"
 6638   6486   
        }
 6639   6487   
        val expected = Endpoint(
 6640   6488   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6641   6489   
        )
 6642   6490   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6643   6491   
        expectEqualEndpoints(expected, actual)
 6644   6492   
    }
 6645   6493   
 6646   6494   
    // {UseFIPS=false, UseDualStack=false, ResourceArn=arn:aws:dynamodb:us-east-1:222222222222:table/table_name, ResourceArnList=[arn:aws:dynamodb:us-east-1:333333333333:table/table_name], AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6647   6495   
    @Test
 6648         -
    fun test365() = runTest {
        6496  +
    fun test355() = runTest {
 6649   6497   
        val params = DynamoDbEndpointParameters {
 6650   6498   
            useFips = false
 6651   6499   
            useDualStack = false
 6652   6500   
            resourceArn = "arn:aws:dynamodb:us-east-1:222222222222:table/table_name"
 6653   6501   
            resourceArnList = listOf("arn:aws:dynamodb:us-east-1:333333333333:table/table_name")
 6654   6502   
            accountIdEndpointMode = "preferred"
 6655   6503   
            region = "us-gov-east-1"
 6656   6504   
        }
 6657   6505   
        val expected = Endpoint(
 6658   6506   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6659   6507   
        )
 6660   6508   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)
 6661   6509   
        expectEqualEndpoints(expected, actual)
 6662   6510   
    }
 6663   6511   
 6664   6512   
    // {UseFIPS=false, UseDualStack=false, AccountIdEndpointMode=preferred, Region=us-gov-east-1}
 6665   6513   
    @Test
 6666         -
    fun test366() = runTest {
        6514  +
    fun test356() = runTest {
 6667   6515   
        val params = DynamoDbEndpointParameters {
 6668   6516   
            useFips = false
 6669   6517   
            useDualStack = false
 6670   6518   
            accountIdEndpointMode = "preferred"
 6671   6519   
            region = "us-gov-east-1"
 6672   6520   
        }
 6673   6521   
        val expected = Endpoint(
 6674   6522   
            uri = Url.parse("https://dynamodb.us-gov-east-1.amazonaws.com"),
 6675   6523   
        )
 6676   6524   
        val actual = DefaultDynamoDbEndpointProvider().resolveEndpoint(params)

tmp-codegen-diff/services/ec2/generated-src/main/kotlin/aws/sdk/kotlin/services/ec2/DefaultEc2Client.kt

@@ -2544,2544 +2660,2685 @@
 2564   2564   
                setIfMissing("Content-Type", "application/x-www-form-urlencoded")
 2565   2565   
            }
 2566   2566   
        )
 2567   2567   
        op.install(UserAgent(awsUserAgentMetadata))
 2568   2568   
        op.install(RecursionDetection())
 2569   2569   
        op.interceptors.addAll(config.interceptors)
 2570   2570   
        return op.roundTrip(client, input)
 2571   2571   
    }
 2572   2572   
 2573   2573   
    /**
 2574         -
     * Initiates an AMI copy operation. You can copy an AMI from one Region to another, or from a Region to an Outpost. You can't copy an AMI from an Outpost to a Region, from one Outpost to another, or within the same Outpost. To copy an AMI to another partition, see [CreateStoreImageTask](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateStoreImageTask.html).
 2575         -
     *
 2576         -
     * When you copy an AMI from one Region to another, the destination Region is the current Region.
 2577         -
     *
 2578         -
     * When you copy an AMI from a Region to an Outpost, specify the ARN of the Outpost as the destination. Backing snapshots copied to an Outpost are encrypted by default using the default encryption key for the Region or the key that you specify. Outposts do not support unencrypted snapshots.
 2579         -
     *
 2580         -
     * For information about the prerequisites when copying an AMI, see [Copy an Amazon EC2 AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html) in the *Amazon EC2 User Guide*.
        2574  +
     * Initiates an AMI copy operation. You must specify the source AMI ID and both the source and destination locations. The copy operation must be initiated in the destination Region.
        2575  +
     *
        2576  +
     * **CopyImage supports the following source to destination copies:**
        2577  +
     * + Region to Region
        2578  +
     * + Region to Outpost
        2579  +
     * + Parent Region to Local Zone
        2580  +
     * + Local Zone to parent Region
        2581  +
     * + Between Local Zones with the same parent Region (only supported for certain Local Zones)
        2582  +
     *
        2583  +
     * **CopyImage does not support the following source to destination copies:**
        2584  +
     * + Local Zone to non-parent Regions
        2585  +
     * + Between Local Zones with different parent Regions
        2586  +
     * + Local Zone to Outpost
        2587  +
     * + Outpost to Local Zone
        2588  +
     * + Outpost to Region
        2589  +
     * + Between Outposts
        2590  +
     * + Within same Outpost
        2591  +
     * + Cross-partition copies (use [CreateStoreImageTask](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateStoreImageTask.html) instead)
        2592  +
     *
        2593  +
     * **Destination specification**
        2594  +
     * + Region to Region: The destination Region is the Region in which you initiate the copy operation.
        2595  +
     * + Region to Outpost: Specify the destination using the `DestinationOutpostArn` parameter (the ARN of the Outpost)
        2596  +
     * + Region to Local Zone, and Local Zone to Local Zone copies: Specify the destination using the `DestinationAvailabilityZone` parameter (the name of the destination Local Zone) or `DestinationAvailabilityZoneId` parameter (the ID of the destination Local Zone).
        2597  +
     *
        2598  +
     * **Snapshot encryption**
        2599  +
     * + Region to Outpost: Backing snapshots copied to an Outpost are encrypted by default using the default encryption key for the Region or the key that you specify. Outposts do not support unencrypted snapshots.
        2600  +
     * + Region to Local Zone, and Local Zone to Local Zone: Not all Local Zones require encrypted snapshots. In Local Zones that require encrypted snapshots, backing snapshots are automatically encrypted during copy. In Local Zones where encryption is not required, snapshots retain their original encryption state (encrypted or unencrypted) by default.
        2601  +
     *
        2602  +
     * For more information, including the required permissions for copying an AMI, see [Copy an Amazon EC2 AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/CopyingAMIs.html) in the *Amazon EC2 User Guide*.
 2581   2603   
     *
 2582   2604   
     * @sample aws.sdk.kotlin.services.ec2.samples.CopyImage.sample
 2583   2605   
     */
 2584   2606   
    override suspend fun copyImage(input: CopyImageRequest): CopyImageResponse {
 2585   2607   
        val op = SdkHttpOperation.build<CopyImageRequest, CopyImageResponse> {
 2586   2608   
            serializeWith = CopyImageOperationSerializer()
 2587   2609   
            deserializeWith = CopyImageOperationDeserializer()
 2588   2610   
            operationName = "CopyImage"
 2589   2611   
            serviceName = ServiceId
 2590   2612   
            telemetry {
 2591   2613   
                provider = config.telemetryProvider
 2592   2614   
                scope = telemetryScope
 2593   2615   
                metrics = opMetrics
 2594   2616   
                attributes = attributesOf {
 2595   2617   
                    "rpc.system" to "aws-api"
 2596   2618   
                }
 2597   2619   
            }
 2598   2620   
            execution.auth = OperationAuthConfig(authSchemeAdapter, configuredAuthSchemes, identityProviderConfig)
 2599   2621   
            execution.endpointResolver = EndpointResolverAdapter(config)
 2600   2622   
            execution.retryStrategy = config.retryStrategy
 2601   2623   
            execution.retryPolicy = config.retryPolicy
 2602   2624   
        }
 2603   2625   
        mergeServiceDefaults(op.context)
 2604   2626   
        op.install(AwsRetryHeaderMiddleware())
 2605   2627   
        op.interceptors.add(AwsSpanInterceptor)
 2606   2628   
        op.interceptors.add(BusinessMetricsInterceptor())
 2607   2629   
        if (config.credentialsProvider is StaticCredentialsProvider) {
 2608   2630   
            op.context.emitBusinessMetric(AwsBusinessMetric.Credentials.CREDENTIALS_CODE)
 2609   2631   
        }
 2610   2632   
        op.install(
 2611   2633   
            MutateHeaders().apply {
 2612   2634   
                setIfMissing("Content-Type", "application/x-www-form-urlencoded")
 2613   2635   
            }
 2614   2636   
        )
 2615   2637   
        op.install(UserAgent(awsUserAgentMetadata))
 2616   2638   
        op.install(RecursionDetection())
 2617   2639   
        op.interceptors.addAll(config.interceptors)
 2618   2640   
        return op.roundTrip(client, input)
 2619   2641   
    }
 2620   2642   
 2621   2643   
    /**
 2622         -
     * Copies a point-in-time snapshot of an EBS volume and stores it in Amazon S3. You can copy a snapshot within the same Region, from one Region to another, or from a Region to an Outpost. You can't copy a snapshot from an Outpost to a Region, from one Outpost to another, or within the same Outpost.
        2644  +
     * Creates an exact copy of an Amazon EBS snapshot.
 2623   2645   
     *
 2624         -
     * You can use the snapshot to create EBS volumes or Amazon Machine Images (AMIs).
        2646  +
     * The location of the source snapshot determines whether you can copy it or not, and the allowed destinations for the snapshot copy.
        2647  +
     * + If the source snapshot is in a Region, you can copy it within that Region, to another Region, to an Outpost associated with that Region, or to a Local Zone in that Region.
        2648  +
     * + If the source snapshot is in a Local Zone, you can copy it within that Local Zone, to another Local Zone in the same zone group, or to the parent Region of the Local Zone.
        2649  +
     * + If the source snapshot is on an Outpost, you can't copy it.
 2625   2650   
     *
 2626         -
     * When copying snapshots to a Region, copies of encrypted EBS snapshots remain encrypted. Copies of unencrypted snapshots remain unencrypted, unless you enable encryption for the snapshot copy operation. By default, encrypted snapshot copies use the default KMS key; however, you can specify a different KMS key. To copy an encrypted snapshot that has been shared from another account, you must have permissions for the KMS key used to encrypt the snapshot.
        2651  +
     * When copying snapshots to a Region, the encryption outcome for the snapshot copy depends on the Amazon EBS encryption by default setting for the destination Region, the encryption status of the source snapshot, and the encryption parameters you specify in the request. For more information, see [ Encryption and snapshot copying](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-copy-snapshot.html#creating-encrypted-snapshots).
 2627   2652   
     *
 2628         -
     * Snapshots copied to an Outpost are encrypted by default using the default encryption key for the Region, or a different key that you specify in the request using **KmsKeyId**. Outposts do not support unencrypted snapshots. For more information, see [Amazon EBS local snapshots on Outposts](https://docs.aws.amazon.com/ebs/latest/userguide/snapshots-outposts.html#ami) in the *Amazon EBS User Guide*.
        2653  +
     * Snapshots copied to an Outpost must be encrypted. Unencrypted snapshots are not supported on Outposts. For more information, [ Amazon EBS local snapshots on Outposts](https://docs.aws.amazon.com/ebs/latest/userguide/snapshots-outposts.html#considerations).
 2629   2654   
     *
 2630         -
     * Snapshots created by copying another snapshot have an arbitrary volume ID that should not be used for any purpose.
        2655  +
     * Snapshots copies have an arbitrary source volume ID. Do not use this volume ID for any purpose.
 2631   2656   
     *
 2632   2657   
     * For more information, see [Copy an Amazon EBS snapshot](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-copy-snapshot.html) in the *Amazon EBS User Guide*.
 2633   2658   
     *
 2634   2659   
     * @sample aws.sdk.kotlin.services.ec2.samples.CopySnapshot.sample
 2635   2660   
     */
 2636   2661   
    override suspend fun copySnapshot(input: CopySnapshotRequest): CopySnapshotResponse {
 2637   2662   
        val op = SdkHttpOperation.build<CopySnapshotRequest, CopySnapshotResponse> {
 2638   2663   
            serializeWith = CopySnapshotOperationSerializer()
 2639   2664   
            deserializeWith = CopySnapshotOperationDeserializer()
 2640   2665   
            operationName = "CopySnapshot"
@@ -3322,3347 +3382,3407 @@
 3342   3367   
        )
 3343   3368   
        op.install(UserAgent(awsUserAgentMetadata))
 3344   3369   
        op.install(RecursionDetection())
 3345   3370   
        op.interceptors.addAll(config.interceptors)
 3346   3371   
        return op.roundTrip(client, input)
 3347   3372   
    }
 3348   3373   
 3349   3374   
    /**
 3350   3375   
     * Creates an Amazon FPGA Image (AFI) from the specified design checkpoint (DCP).
 3351   3376   
     *
 3352         -
     * The create operation is asynchronous. To verify that the AFI is ready for use, check the output logs.
        3377  +
     * The create operation is asynchronous. To verify that the AFI was successfully created and is ready for use, check the output logs.
 3353   3378   
     *
 3354   3379   
     * An AFI contains the FPGA bitstream that is ready to download to an FPGA. You can securely deploy an AFI on multiple FPGA-accelerated instances. For more information, see the [Amazon Web Services FPGA Hardware Development Kit](https://github.com/aws/aws-fpga/).
 3355   3380   
     */
 3356   3381   
    override suspend fun createFpgaImage(input: CreateFpgaImageRequest): CreateFpgaImageResponse {
 3357   3382   
        val op = SdkHttpOperation.build<CreateFpgaImageRequest, CreateFpgaImageResponse> {
 3358   3383   
            serializeWith = CreateFpgaImageOperationSerializer()
 3359   3384   
            deserializeWith = CreateFpgaImageOperationDeserializer()
 3360   3385   
            operationName = "CreateFpgaImage"
 3361   3386   
            serviceName = ServiceId
 3362   3387   
            telemetry {
@@ -3411,3436 +3470,3537 @@
 3431   3456   
            MutateHeaders().apply {
 3432   3457   
                setIfMissing("Content-Type", "application/x-www-form-urlencoded")
 3433   3458   
            }
 3434   3459   
        )
 3435   3460   
        op.install(UserAgent(awsUserAgentMetadata))
 3436   3461   
        op.install(RecursionDetection())
 3437   3462   
        op.interceptors.addAll(config.interceptors)
 3438   3463   
        return op.roundTrip(client, input)
 3439   3464   
    }
 3440   3465   
        3466  +
    /**
        3467  +
     * Creates a report that shows how your image is used across other Amazon Web Services accounts. The report provides visibility into which accounts are using the specified image, and how many resources (EC2 instances or launch templates) are referencing it.
        3468  +
     *
        3469  +
     * For more information, see [View your AMI usage](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/your-ec2-ami-usage.html) in the *Amazon EC2 User Guide*.
        3470  +
     */
        3471  +
    override suspend fun createImageUsageReport(input: CreateImageUsageReportRequest): CreateImageUsageReportResponse {
        3472  +
        val op = SdkHttpOperation.build<CreateImageUsageReportRequest, CreateImageUsageReportResponse> {
        3473  +
            serializeWith = CreateImageUsageReportOperationSerializer()
        3474  +
            deserializeWith = CreateImageUsageReportOperationDeserializer()
        3475  +
            operationName = "CreateImageUsageReport"
        3476  +
            serviceName = ServiceId
        3477  +
            telemetry {
        3478  +
                provider = config.telemetryProvider
        3479  +
                scope = telemetryScope
        3480  +
                metrics = opMetrics
        3481  +
                attributes = attributesOf {
        3482  +
                    "rpc.system" to "aws-api"
        3483  +
                }
        3484  +
            }
        3485  +
            execution.auth = OperationAuthConfig(authSchemeAdapter, configuredAuthSchemes, identityProviderConfig)
        3486  +
            execution.endpointResolver = EndpointResolverAdapter(config)
        3487  +
            execution.retryStrategy = config.retryStrategy
        3488  +
            execution.retryPolicy = config.retryPolicy
        3489  +
        }
        3490  +
        mergeServiceDefaults(op.context)
        3491  +
        op.install(AwsRetryHeaderMiddleware())
        3492  +
        op.interceptors.add(AwsSpanInterceptor)
        3493  +
        op.interceptors.add(BusinessMetricsInterceptor())
        3494  +
        if (config.credentialsProvider is StaticCredentialsProvider) {
        3495  +
            op.context.emitBusinessMetric(AwsBusinessMetric.Credentials.CREDENTIALS_CODE)
        3496  +
        }
        3497  +
        op.install(
        3498  +
            MutateHeaders().apply {
        3499  +
                setIfMissing("Content-Type", "application/x-www-form-urlencoded")
        3500  +
            }
        3501  +
        )
        3502  +
        op.install(UserAgent(awsUserAgentMetadata))
        3503  +
        op.install(RecursionDetection())
        3504  +
        op.interceptors.addAll(config.interceptors)
        3505  +
        return op.roundTrip(client, input)
        3506  +
    }
        3507  +
 3441   3508   
    /**
 3442   3509   
     * Creates an EC2 Instance Connect Endpoint.
 3443   3510   
     *
 3444   3511   
     * An EC2 Instance Connect Endpoint allows you to connect to an instance, without requiring the instance to have a public IPv4 or public IPv6 address. For more information, see [Connect to your instances using EC2 Instance Connect Endpoint](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Connect-using-EC2-Instance-Connect-Endpoint.html) in the *Amazon EC2 User Guide*.
 3445   3512   
     */
 3446   3513   
    override suspend fun createInstanceConnectEndpoint(input: CreateInstanceConnectEndpointRequest): CreateInstanceConnectEndpointResponse {
 3447   3514   
        val op = SdkHttpOperation.build<CreateInstanceConnectEndpointRequest, CreateInstanceConnectEndpointResponse> {
 3448   3515   
            serializeWith = CreateInstanceConnectEndpointOperationSerializer()
 3449   3516   
            deserializeWith = CreateInstanceConnectEndpointOperationDeserializer()
 3450   3517   
            operationName = "CreateInstanceConnectEndpoint"
@@ -7132,7199 +7191,7300 @@
 7152   7219   
            MutateHeaders().apply {
 7153   7220   
                setIfMissing("Content-Type", "application/x-www-form-urlencoded")
 7154   7221   
            }
 7155   7222   
        )
 7156   7223   
        op.install(UserAgent(awsUserAgentMetadata))
 7157   7224   
        op.install(RecursionDetection())
 7158   7225   
        op.interceptors.addAll(config.interceptors)
 7159   7226   
        return op.roundTrip(client, input)
 7160   7227   
    }
 7161   7228   
        7229  +
    /**
        7230  +
     * Deletes the specified image usage report.
        7231  +
     *
        7232  +
     * For more information, see [View your AMI usage](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/your-ec2-ami-usage.html) in the *Amazon EC2 User Guide*.
        7233  +
     */
        7234  +
    override suspend fun deleteImageUsageReport(input: DeleteImageUsageReportRequest): DeleteImageUsageReportResponse {
        7235  +
        val op = SdkHttpOperation.build<DeleteImageUsageReportRequest, DeleteImageUsageReportResponse> {
        7236  +
            serializeWith = DeleteImageUsageReportOperationSerializer()
        7237  +
            deserializeWith = DeleteImageUsageReportOperationDeserializer()
        7238  +
            operationName = "DeleteImageUsageReport"
        7239  +
            serviceName = ServiceId
        7240  +
            telemetry {
        7241  +
                provider = config.telemetryProvider
        7242  +
                scope = telemetryScope
        7243  +
                metrics = opMetrics
        7244  +
                attributes = attributesOf {
        7245  +
                    "rpc.system" to "aws-api"
        7246  +
                }
        7247  +
            }
        7248  +
            execution.auth = OperationAuthConfig(authSchemeAdapter, configuredAuthSchemes, identityProviderConfig)
        7249  +
            execution.endpointResolver = EndpointResolverAdapter(config)
        7250  +
            execution.retryStrategy = config.retryStrategy
        7251  +
            execution.retryPolicy = config.retryPolicy
        7252  +
        }
        7253  +
        mergeServiceDefaults(op.context)
        7254  +
        op.install(AwsRetryHeaderMiddleware())
        7255  +
        op.interceptors.add(AwsSpanInterceptor)
        7256  +
        op.interceptors.add(BusinessMetricsInterceptor())
        7257  +
        if (config.credentialsProvider is StaticCredentialsProvider) {
        7258  +
            op.context.emitBusinessMetric(AwsBusinessMetric.Credentials.CREDENTIALS_CODE)
        7259  +
        }
        7260  +
        op.install(
        7261  +
            MutateHeaders().apply {
        7262  +
                setIfMissing("Content-Type", "application/x-www-form-urlencoded")
        7263  +
            }
        7264  +
        )
        7265  +
        op.install(UserAgent(awsUserAgentMetadata))
        7266  +
        op.install(RecursionDetection())
        7267  +
        op.interceptors.addAll(config.interceptors)
        7268  +
        return op.roundTrip(client, input)
        7269  +
    }
        7270  +
 7162   7271   
    /**
 7163   7272   
     * Deletes the specified EC2 Instance Connect Endpoint.
 7164   7273   
     */
 7165   7274   
    override suspend fun deleteInstanceConnectEndpoint(input: DeleteInstanceConnectEndpointRequest): DeleteInstanceConnectEndpointResponse {
 7166   7275   
        val op = SdkHttpOperation.build<DeleteInstanceConnectEndpointRequest, DeleteInstanceConnectEndpointResponse> {
 7167   7276   
            serializeWith = DeleteInstanceConnectEndpointOperationSerializer()
 7168   7277   
            deserializeWith = DeleteInstanceConnectEndpointOperationDeserializer()
 7169   7278   
            operationName = "DeleteInstanceConnectEndpoint"
 7170   7279   
            serviceName = ServiceId
 7171   7280   
            telemetry {
@@ -12366,12475 +12425,12660 @@
12386  12495   
            MutateHeaders().apply {
12387  12496   
                setIfMissing("Content-Type", "application/x-www-form-urlencoded")
12388  12497   
            }
12389  12498   
        )
12390  12499   
        op.install(UserAgent(awsUserAgentMetadata))
12391  12500   
        op.install(RecursionDetection())
12392  12501   
        op.interceptors.addAll(config.interceptors)
12393  12502   
        return op.roundTrip(client, input)
12394  12503   
    }
12395  12504   
       12505  +
    /**
       12506  +
     * Describes your Amazon Web Services resources that are referencing the specified images.
       12507  +
     *
       12508  +
     * For more information, see [Identify your resources referencing specified AMIs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-ami-references.html) in the *Amazon EC2 User Guide*.
       12509  +
     */
       12510  +
    override suspend fun describeImageReferences(input: DescribeImageReferencesRequest): DescribeImageReferencesResponse {
       12511  +
        val op = SdkHttpOperation.build<DescribeImageReferencesRequest, DescribeImageReferencesResponse> {
       12512  +
            serializeWith = DescribeImageReferencesOperationSerializer()
       12513  +
            deserializeWith = DescribeImageReferencesOperationDeserializer()
       12514  +
            operationName = "DescribeImageReferences"
       12515  +
            serviceName = ServiceId
       12516  +
            telemetry {
       12517  +
                provider = config.telemetryProvider
       12518  +
                scope = telemetryScope
       12519  +
                metrics = opMetrics
       12520  +
                attributes = attributesOf {
       12521  +
                    "rpc.system" to "aws-api"
       12522  +
                }
       12523  +
            }
       12524  +
            execution.auth = OperationAuthConfig(authSchemeAdapter, configuredAuthSchemes, identityProviderConfig)
       12525  +
            execution.endpointResolver = EndpointResolverAdapter(config)
       12526  +
            execution.retryStrategy = config.retryStrategy
       12527  +
            execution.retryPolicy = config.retryPolicy
       12528  +
        }
       12529  +
        mergeServiceDefaults(op.context)
       12530  +
        op.install(AwsRetryHeaderMiddleware())
       12531  +
        op.interceptors.add(AwsSpanInterceptor)
       12532  +
        op.interceptors.add(BusinessMetricsInterceptor())
       12533  +
        if (config.credentialsProvider is StaticCredentialsProvider) {
       12534  +
            op.context.emitBusinessMetric(AwsBusinessMetric.Credentials.CREDENTIALS_CODE)
       12535  +
        }
       12536  +
        op.install(
       12537  +
            MutateHeaders().apply {
       12538  +
                setIfMissing("Content-Type", "application/x-www-form-urlencoded")
       12539  +
            }
       12540  +
        )
       12541  +
        op.install(UserAgent(awsUserAgentMetadata))
       12542  +
        op.install(RecursionDetection())
       12543  +
        op.interceptors.addAll(config.interceptors)
       12544  +
        return op.roundTrip(client, input)
       12545  +
    }
       12546  +
       12547  +
    /**
       12548  +
     * Describes the entries in image usage reports, showing how your images are used across other Amazon Web Services accounts.
       12549  +
     *
       12550  +
     * For more information, see [View your AMI usage](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/your-ec2-ami-usage.html) in the *Amazon EC2 User Guide*.
       12551  +
     */
       12552  +
    override suspend fun describeImageUsageReportEntries(input: DescribeImageUsageReportEntriesRequest): DescribeImageUsageReportEntriesResponse {
       12553  +
        val op = SdkHttpOperation.build<DescribeImageUsageReportEntriesRequest, DescribeImageUsageReportEntriesResponse> {
       12554  +
            serializeWith = DescribeImageUsageReportEntriesOperationSerializer()
       12555  +
            deserializeWith = DescribeImageUsageReportEntriesOperationDeserializer()
       12556  +
            operationName = "DescribeImageUsageReportEntries"
       12557  +
            serviceName = ServiceId
       12558  +
            telemetry {
       12559  +
                provider = config.telemetryProvider
       12560  +
                scope = telemetryScope
       12561  +
                metrics = opMetrics
       12562  +
                attributes = attributesOf {
       12563  +
                    "rpc.system" to "aws-api"
       12564  +
                }
       12565  +
            }
       12566  +
            execution.auth = OperationAuthConfig(authSchemeAdapter, configuredAuthSchemes, identityProviderConfig)
       12567  +
            execution.endpointResolver = EndpointResolverAdapter(config)
       12568  +
            execution.retryStrategy = config.retryStrategy
       12569  +
            execution.retryPolicy = config.retryPolicy
       12570  +
        }
       12571  +
        mergeServiceDefaults(op.context)
       12572  +
        op.install(AwsRetryHeaderMiddleware())
       12573  +
        op.interceptors.add(AwsSpanInterceptor)
       12574  +
        op.interceptors.add(BusinessMetricsInterceptor())
       12575  +
        if (config.credentialsProvider is StaticCredentialsProvider) {
       12576  +
            op.context.emitBusinessMetric(AwsBusinessMetric.Credentials.CREDENTIALS_CODE)
       12577  +
        }
       12578  +
        op.install(
       12579  +
            MutateHeaders().apply {
       12580  +
                setIfMissing("Content-Type", "application/x-www-form-urlencoded")
       12581  +
            }
       12582  +
        )
       12583  +
        op.install(UserAgent(awsUserAgentMetadata))
       12584  +
        op.install(RecursionDetection())
       12585  +
        op.interceptors.addAll(config.interceptors)
       12586  +
        return op.roundTrip(client, input)
       12587  +
    }
       12588  +
       12589  +
    /**
       12590  +
     * Describes the configuration and status of image usage reports, filtered by report IDs or image IDs.
       12591  +
     *
       12592  +
     * For more information, see [View your AMI usage](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/your-ec2-ami-usage.html) in the *Amazon EC2 User Guide*.
       12593  +
     */
       12594  +
    override suspend fun describeImageUsageReports(input: DescribeImageUsageReportsRequest): DescribeImageUsageReportsResponse {
       12595  +
        val op = SdkHttpOperation.build<DescribeImageUsageReportsRequest, DescribeImageUsageReportsResponse> {
       12596  +
            serializeWith = DescribeImageUsageReportsOperationSerializer()
       12597  +
            deserializeWith = DescribeImageUsageReportsOperationDeserializer()
       12598  +
            operationName = "DescribeImageUsageReports"
       12599  +
            serviceName = ServiceId
       12600  +
            telemetry {
       12601  +
                provider = config.telemetryProvider
       12602  +
                scope = telemetryScope
       12603  +
                metrics = opMetrics
       12604  +
                attributes = attributesOf {
       12605  +
                    "rpc.system" to "aws-api"
       12606  +
                }
       12607  +
            }
       12608  +
            execution.auth = OperationAuthConfig(authSchemeAdapter, configuredAuthSchemes, identityProviderConfig)
       12609  +
            execution.endpointResolver = EndpointResolverAdapter(config)
       12610  +
            execution.retryStrategy = config.retryStrategy
       12611  +
            execution.retryPolicy = config.retryPolicy
       12612  +
        }
       12613  +
        mergeServiceDefaults(op.context)
       12614  +
        op.install(AwsRetryHeaderMiddleware())
       12615  +
        op.interceptors.add(AwsSpanInterceptor)
       12616  +
        op.interceptors.add(BusinessMetricsInterceptor())
       12617  +
        if (config.credentialsProvider is StaticCredentialsProvider) {
       12618  +
            op.context.emitBusinessMetric(AwsBusinessMetric.Credentials.CREDENTIALS_CODE)
       12619  +
        }
       12620  +
        op.install(
       12621  +
            MutateHeaders().apply {
       12622  +
                setIfMissing("Content-Type", "application/x-www-form-urlencoded")
       12623  +
            }
       12624  +
        )
       12625  +
        op.install(UserAgent(awsUserAgentMetadata))
       12626  +
        op.install(RecursionDetection())
       12627  +
        op.interceptors.addAll(config.interceptors)
       12628  +
        return op.roundTrip(client, input)
       12629  +
    }
       12630  +
12396  12631   
    /**
12397  12632   
     * Describes the specified images (AMIs, AKIs, and ARIs) available to you or all of the images available to you.
12398  12633   
     *
12399  12634   
     * The images available to you include public images, private images that you own, and private images owned by other Amazon Web Services accounts for which you have explicit launch permissions.
12400  12635   
     *
12401  12636   
     * Recently deregistered images appear in the returned results for a short interval and then return empty results. After all instances that reference a deregistered AMI are terminated, specifying the ID of the image will eventually return an error indicating that the AMI ID cannot be found.
12402  12637   
     *
12403  12638   
     * When Allowed AMIs is set to `enabled`, only allowed images are returned in the results, with the `imageAllowed` field set to `true` for each image. In `audit-mode`, the `imageAllowed` field is set to `true` for images that meet the account's Allowed AMIs criteria, and `false` for images that don't meet the criteria. For more information, see [Allowed AMIs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-allowed-amis.html).
12404  12639   
     *
12405  12640   
     * The Amazon EC2 API follows an eventual consistency model. This means that the result of an API command you run that creates or modifies resources might not be immediately available to all subsequent commands you run. For guidance on how to manage eventual consistency, see [Eventual consistency in the Amazon EC2 API](https://docs.aws.amazon.com/ec2/latest/devguide/eventual-consistency.html) in the *Amazon EC2 Developer Guide*.
@@ -18076,18311 +18137,18370 @@
18096  18331   
        )
18097  18332   
        op.install(UserAgent(awsUserAgentMetadata))
18098  18333   
        op.install(RecursionDetection())
18099  18334   
        op.interceptors.addAll(config.interceptors)
18100  18335   
        return op.roundTrip(client, input)
18101  18336   
    }
18102  18337   
18103  18338   
    /**
18104  18339   
     * Disables *block public access for AMIs* at the account level in the specified Amazon Web Services Region. This removes the *block public access* restriction from your account. With the restriction removed, you can publicly share your AMIs in the specified Amazon Web Services Region.
18105  18340   
     *
18106         -
     * The API can take up to 10 minutes to configure this setting. During this time, if you run [GetImageBlockPublicAccessState](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetImageBlockPublicAccessState.html), the response will be `block-new-sharing`. When the API has completed the configuration, the response will be `unblocked`.
18107         -
     *
18108  18341   
     * For more information, see [Block public access to your AMIs](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-public-access-to-amis.html) in the *Amazon EC2 User Guide*.
18109  18342   
     */
18110  18343   
    override suspend fun disableImageBlockPublicAccess(input: DisableImageBlockPublicAccessRequest): DisableImageBlockPublicAccessResponse {
18111  18344   
        val op = SdkHttpOperation.build<DisableImageBlockPublicAccessRequest, DisableImageBlockPublicAccessResponse> {
18112  18345   
            serializeWith = DisableImageBlockPublicAccessOperationSerializer()
18113  18346   
            deserializeWith = DisableImageBlockPublicAccessOperationDeserializer()
18114  18347   
            operationName = "DisableImageBlockPublicAccess"
18115  18348   
            serviceName = ServiceId
18116  18349   
            telemetry {
18117  18350   
                provider = config.telemetryProvider
@@ -23737,23970 +23796,24071 @@
23757  23990   
            MutateHeaders().apply {
23758  23991   
                setIfMissing("Content-Type", "application/x-www-form-urlencoded")
23759  23992   
            }
23760  23993   
        )
23761  23994   
        op.install(UserAgent(awsUserAgentMetadata))
23762  23995   
        op.install(RecursionDetection())
23763  23996   
        op.interceptors.addAll(config.interceptors)
23764  23997   
        return op.roundTrip(client, input)
23765  23998   
    }
23766  23999   
       24000  +
    /**
       24001  +
     * Modifies the specified EC2 Instance Connect Endpoint.
       24002  +
     *
       24003  +
     * For more information, see [Modify an EC2 Instance Connect Endpoint](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/modify-ec2-instance-connect-endpoint.html) in the *Amazon EC2 User Guide*.
       24004  +
     */
       24005  +
    override suspend fun modifyInstanceConnectEndpoint(input: ModifyInstanceConnectEndpointRequest): ModifyInstanceConnectEndpointResponse {
       24006  +
        val op = SdkHttpOperation.build<ModifyInstanceConnectEndpointRequest, ModifyInstanceConnectEndpointResponse> {
       24007  +
            serializeWith = ModifyInstanceConnectEndpointOperationSerializer()
       24008  +
            deserializeWith = ModifyInstanceConnectEndpointOperationDeserializer()
       24009  +
            operationName = "ModifyInstanceConnectEndpoint"
       24010  +
            serviceName = ServiceId
       24011  +
            telemetry {
       24012  +
                provider = config.telemetryProvider
       24013  +
                scope = telemetryScope
       24014  +
                metrics = opMetrics
       24015  +
                attributes = attributesOf {
       24016  +
                    "rpc.system" to "aws-api"
       24017  +
                }
       24018  +
            }
       24019  +
            execution.auth = OperationAuthConfig(authSchemeAdapter, configuredAuthSchemes, identityProviderConfig)
       24020  +
            execution.endpointResolver = EndpointResolverAdapter(config)
       24021  +
            execution.retryStrategy = config.retryStrategy
       24022  +
            execution.retryPolicy = config.retryPolicy
       24023  +
        }
       24024  +
        mergeServiceDefaults(op.context)
       24025  +
        op.install(AwsRetryHeaderMiddleware())
       24026  +
        op.interceptors.add(AwsSpanInterceptor)
       24027  +
        op.interceptors.add(BusinessMetricsInterceptor())
       24028  +
        if (config.credentialsProvider is StaticCredentialsProvider) {
       24029  +
            op.context.emitBusinessMetric(AwsBusinessMetric.Credentials.CREDENTIALS_CODE)
       24030  +
        }
       24031  +
        op.install(
       24032  +
            MutateHeaders().apply {
       24033  +
                setIfMissing("Content-Type", "application/x-www-form-urlencoded")
       24034  +
            }
       24035  +
        )
       24036  +
        op.install(UserAgent(awsUserAgentMetadata))
       24037  +
        op.install(RecursionDetection())
       24038  +
        op.interceptors.addAll(config.interceptors)
       24039  +
        return op.roundTrip(client, input)
       24040  +
    }
       24041  +
23767  24042   
    /**
23768  24043   
     * By default, all vCPUs for the instance type are active when you launch an instance. When you configure the number of active vCPUs for the instance, it can help you save on licensing costs and optimize performance. The base cost of the instance remains unchanged.
23769  24044   
     *
23770  24045   
     * The number of active vCPUs equals the number of threads per CPU core multiplied by the number of cores. The instance must be in a `Stopped` state before you make changes.
23771  24046   
     *
23772  24047   
     * Some instance type options do not support this capability. For more information, see [Supported CPU options](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/cpu-options-supported-instances-values.html) in the *Amazon EC2 User Guide*.
23773  24048   
     */
23774  24049   
    override suspend fun modifyInstanceCpuOptions(input: ModifyInstanceCpuOptionsRequest): ModifyInstanceCpuOptionsResponse {
23775  24050   
        val op = SdkHttpOperation.build<ModifyInstanceCpuOptionsRequest, ModifyInstanceCpuOptionsResponse> {
23776  24051   
            serializeWith = ModifyInstanceCpuOptionsOperationSerializer()