// Code generated by smithy-go-codegen DO NOT EDIT.


package ecs

import (
	"context"
	"net/http"
	"github.com/aws/smithy-go/ptr"
	"reflect"
	smithy "github.com/aws/smithy-go"
	smithyendpoints "github.com/aws/smithy-go/endpoints"
	"strings"
	"testing"
	"net/url"
)

// For region af-south-1 with FIPS disabled and DualStack disabled
func TestEndpointCase0(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("af-south-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.af-south-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region ap-east-1 with FIPS disabled and DualStack disabled
func TestEndpointCase1(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("ap-east-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.ap-east-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region ap-northeast-1 with FIPS disabled and DualStack disabled
func TestEndpointCase2(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("ap-northeast-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.ap-northeast-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region ap-northeast-2 with FIPS disabled and DualStack disabled
func TestEndpointCase3(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("ap-northeast-2"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.ap-northeast-2.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region ap-northeast-3 with FIPS disabled and DualStack disabled
func TestEndpointCase4(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("ap-northeast-3"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.ap-northeast-3.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region ap-south-1 with FIPS disabled and DualStack disabled
func TestEndpointCase5(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("ap-south-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.ap-south-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region ap-southeast-1 with FIPS disabled and DualStack disabled
func TestEndpointCase6(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("ap-southeast-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.ap-southeast-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region ap-southeast-2 with FIPS disabled and DualStack disabled
func TestEndpointCase7(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("ap-southeast-2"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.ap-southeast-2.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region ap-southeast-3 with FIPS disabled and DualStack disabled
func TestEndpointCase8(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("ap-southeast-3"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.ap-southeast-3.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region ca-central-1 with FIPS disabled and DualStack disabled
func TestEndpointCase9(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("ca-central-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.ca-central-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region eu-central-1 with FIPS disabled and DualStack disabled
func TestEndpointCase10(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("eu-central-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.eu-central-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region eu-north-1 with FIPS disabled and DualStack disabled
func TestEndpointCase11(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("eu-north-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.eu-north-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region eu-south-1 with FIPS disabled and DualStack disabled
func TestEndpointCase12(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("eu-south-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.eu-south-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region eu-west-1 with FIPS disabled and DualStack disabled
func TestEndpointCase13(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("eu-west-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.eu-west-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region eu-west-2 with FIPS disabled and DualStack disabled
func TestEndpointCase14(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("eu-west-2"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.eu-west-2.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region eu-west-3 with FIPS disabled and DualStack disabled
func TestEndpointCase15(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("eu-west-3"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.eu-west-3.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region me-south-1 with FIPS disabled and DualStack disabled
func TestEndpointCase16(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("me-south-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.me-south-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region sa-east-1 with FIPS disabled and DualStack disabled
func TestEndpointCase17(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("sa-east-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.sa-east-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-east-1 with FIPS disabled and DualStack disabled
func TestEndpointCase18(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-east-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.us-east-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-east-1 with FIPS enabled and DualStack disabled
func TestEndpointCase19(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-east-1"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs-fips.us-east-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-east-2 with FIPS disabled and DualStack disabled
func TestEndpointCase20(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-east-2"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.us-east-2.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-east-2 with FIPS enabled and DualStack disabled
func TestEndpointCase21(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-east-2"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs-fips.us-east-2.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-west-1 with FIPS disabled and DualStack disabled
func TestEndpointCase22(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-west-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.us-west-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-west-1 with FIPS enabled and DualStack disabled
func TestEndpointCase23(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-west-1"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs-fips.us-west-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-west-2 with FIPS disabled and DualStack disabled
func TestEndpointCase24(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-west-2"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.us-west-2.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-west-2 with FIPS enabled and DualStack disabled
func TestEndpointCase25(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-west-2"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs-fips.us-west-2.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-east-1 with FIPS enabled and DualStack enabled
func TestEndpointCase26(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-east-1"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(true),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs-fips.us-east-1.api.aws")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-east-1 with FIPS disabled and DualStack enabled
func TestEndpointCase27(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-east-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(true),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.us-east-1.api.aws")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region cn-north-1 with FIPS disabled and DualStack disabled
func TestEndpointCase28(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("cn-north-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.cn-north-1.amazonaws.com.cn")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region cn-northwest-1 with FIPS disabled and DualStack disabled
func TestEndpointCase29(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("cn-northwest-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.cn-northwest-1.amazonaws.com.cn")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region cn-north-1 with FIPS enabled and DualStack enabled
func TestEndpointCase30(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("cn-north-1"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(true),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs-fips.cn-north-1.api.amazonwebservices.com.cn")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region cn-north-1 with FIPS enabled and DualStack disabled
func TestEndpointCase31(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("cn-north-1"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs-fips.cn-north-1.amazonaws.com.cn")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region cn-north-1 with FIPS disabled and DualStack enabled
func TestEndpointCase32(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("cn-north-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(true),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.cn-north-1.api.amazonwebservices.com.cn")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-gov-east-1 with FIPS disabled and DualStack disabled
func TestEndpointCase33(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-gov-east-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.us-gov-east-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-gov-east-1 with FIPS enabled and DualStack disabled
func TestEndpointCase34(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-gov-east-1"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs-fips.us-gov-east-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-gov-west-1 with FIPS disabled and DualStack disabled
func TestEndpointCase35(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-gov-west-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.us-gov-west-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-gov-west-1 with FIPS enabled and DualStack disabled
func TestEndpointCase36(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-gov-west-1"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs-fips.us-gov-west-1.amazonaws.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-gov-east-1 with FIPS enabled and DualStack enabled
func TestEndpointCase37(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-gov-east-1"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(true),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs-fips.us-gov-east-1.api.aws")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-gov-east-1 with FIPS disabled and DualStack enabled
func TestEndpointCase38(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-gov-east-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(true),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.us-gov-east-1.api.aws")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-iso-east-1 with FIPS disabled and DualStack disabled
func TestEndpointCase39(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-iso-east-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.us-iso-east-1.c2s.ic.gov")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-iso-west-1 with FIPS disabled and DualStack disabled
func TestEndpointCase40(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-iso-west-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.us-iso-west-1.c2s.ic.gov")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-iso-east-1 with FIPS enabled and DualStack enabled
func TestEndpointCase41(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-iso-east-1"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(true),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err == nil {
    t.Fatalf("expect error, got none")
}
if e, a := "FIPS and DualStack are enabled, but this partition does not support one or both", err.Error(); !strings.Contains(a, e) {
    t.Errorf("expect %v error in %v", e, a)
}
}

// For region us-iso-east-1 with FIPS enabled and DualStack disabled
func TestEndpointCase42(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-iso-east-1"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs-fips.us-iso-east-1.c2s.ic.gov")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-iso-east-1 with FIPS disabled and DualStack enabled
func TestEndpointCase43(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-iso-east-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(true),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err == nil {
    t.Fatalf("expect error, got none")
}
if e, a := "DualStack is enabled but this partition does not support DualStack", err.Error(); !strings.Contains(a, e) {
    t.Errorf("expect %v error in %v", e, a)
}
}

// For region us-isob-east-1 with FIPS disabled and DualStack disabled
func TestEndpointCase44(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-isob-east-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs.us-isob-east-1.sc2s.sgov.gov")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-isob-east-1 with FIPS enabled and DualStack enabled
func TestEndpointCase45(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-isob-east-1"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(true),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err == nil {
    t.Fatalf("expect error, got none")
}
if e, a := "FIPS and DualStack are enabled, but this partition does not support one or both", err.Error(); !strings.Contains(a, e) {
    t.Errorf("expect %v error in %v", e, a)
}
}

// For region us-isob-east-1 with FIPS enabled and DualStack disabled
func TestEndpointCase46(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-isob-east-1"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(false),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://ecs-fips.us-isob-east-1.sc2s.sgov.gov")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For region us-isob-east-1 with FIPS disabled and DualStack enabled
func TestEndpointCase47(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-isob-east-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(true),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err == nil {
    t.Fatalf("expect error, got none")
}
if e, a := "DualStack is enabled but this partition does not support DualStack", err.Error(); !strings.Contains(a, e) {
    t.Errorf("expect %v error in %v", e, a)
}
}

// For custom endpoint with region set and fips disabled and dualstack disabled
func TestEndpointCase48(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-east-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
Endpoint: ptr.String("https://example.com"),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://example.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For custom endpoint with region not set and fips disabled and dualstack disabled
func TestEndpointCase49(t *testing.T) {
    var params = EndpointParameters{
    UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(false),
Endpoint: ptr.String("https://example.com"),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err != nil {
    t.Fatalf("expect no error, got %v", err)
}

uri, _ := url.Parse("https://example.com")

expectEndpoint := smithyendpoints.Endpoint{
    URI: *uri,
    Headers: http.Header{},
    Properties: smithy.Properties{},
}

if e, a := expectEndpoint.URI, result.URI; e != a{
    t.Errorf("expect %v URI, got %v", e, a)
}

if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
}

if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
}
}

// For custom endpoint with fips enabled and dualstack disabled
func TestEndpointCase50(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-east-1"),
UseFIPS: ptr.Bool(true),
UseDualStack: ptr.Bool(false),
Endpoint: ptr.String("https://example.com"),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err == nil {
    t.Fatalf("expect error, got none")
}
if e, a := "Invalid Configuration: FIPS and custom endpoint are not supported", err.Error(); !strings.Contains(a, e) {
    t.Errorf("expect %v error in %v", e, a)
}
}

// For custom endpoint with fips disabled and dualstack enabled
func TestEndpointCase51(t *testing.T) {
    var params = EndpointParameters{
    Region: ptr.String("us-east-1"),
UseFIPS: ptr.Bool(false),
UseDualStack: ptr.Bool(true),
Endpoint: ptr.String("https://example.com"),
}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err == nil {
    t.Fatalf("expect error, got none")
}
if e, a := "Invalid Configuration: Dualstack and custom endpoint are not supported", err.Error(); !strings.Contains(a, e) {
    t.Errorf("expect %v error in %v", e, a)
}
}

// Missing region
func TestEndpointCase52(t *testing.T) {
    var params = EndpointParameters{

}

resolver := NewDefaultEndpointResolverV2()
result, err := resolver.ResolveEndpoint(context.Background(), params)
_, _ = result, err

if err == nil {
    t.Fatalf("expect error, got none")
}
if e, a := "Invalid Configuration: Missing Region", err.Error(); !strings.Contains(a, e) {
    t.Errorf("expect %v error in %v", e, a)
}
}
