Source file src/github.com/aws/aws-sdk-go-v2/service/sts/endpoints_test.go

Documentation: github.com/aws/aws-sdk-go-v2/service/sts

     1  // Code generated by smithy-go-codegen DO NOT EDIT.
     2  
     3  package sts
     4  
     5  import (
     6  	"context"
     7  	smithy "github.com/aws/smithy-go"
     8  	smithyauth "github.com/aws/smithy-go/auth"
     9  	smithyendpoints "github.com/aws/smithy-go/endpoints"
    10  	"github.com/aws/smithy-go/ptr"
    11  	smithyhttp "github.com/aws/smithy-go/transport/http"
    12  	"net/http"
    13  	"net/url"
    14  	"reflect"
    15  	"strings"
    16  	"testing"
    17  )
    18  
    19  // For region af-south-1 with FIPS disabled and DualStack disabled
    20  func TestEndpointCase0(t *testing.T) {
    21  	var params = EndpointParameters{
    22  		Region:       ptr.String("af-south-1"),
    23  		UseFIPS:      ptr.Bool(false),
    24  		UseDualStack: ptr.Bool(false),
    25  	}
    26  
    27  	resolver := NewDefaultEndpointResolverV2()
    28  	result, err := resolver.ResolveEndpoint(context.Background(), params)
    29  	_, _ = result, err
    30  
    31  	if err != nil {
    32  		t.Fatalf("expect no error, got %v", err)
    33  	}
    34  
    35  	uri, _ := url.Parse("https://sts.af-south-1.amazonaws.com")
    36  
    37  	expectEndpoint := smithyendpoints.Endpoint{
    38  		URI:        *uri,
    39  		Headers:    http.Header{},
    40  		Properties: smithy.Properties{},
    41  	}
    42  
    43  	if e, a := expectEndpoint.URI, result.URI; e != a {
    44  		t.Errorf("expect %v URI, got %v", e, a)
    45  	}
    46  
    47  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    48  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
    49  	}
    50  
    51  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    52  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
    53  	}
    54  }
    55  
    56  // For region ap-east-1 with FIPS disabled and DualStack disabled
    57  func TestEndpointCase1(t *testing.T) {
    58  	var params = EndpointParameters{
    59  		Region:       ptr.String("ap-east-1"),
    60  		UseFIPS:      ptr.Bool(false),
    61  		UseDualStack: ptr.Bool(false),
    62  	}
    63  
    64  	resolver := NewDefaultEndpointResolverV2()
    65  	result, err := resolver.ResolveEndpoint(context.Background(), params)
    66  	_, _ = result, err
    67  
    68  	if err != nil {
    69  		t.Fatalf("expect no error, got %v", err)
    70  	}
    71  
    72  	uri, _ := url.Parse("https://sts.ap-east-1.amazonaws.com")
    73  
    74  	expectEndpoint := smithyendpoints.Endpoint{
    75  		URI:        *uri,
    76  		Headers:    http.Header{},
    77  		Properties: smithy.Properties{},
    78  	}
    79  
    80  	if e, a := expectEndpoint.URI, result.URI; e != a {
    81  		t.Errorf("expect %v URI, got %v", e, a)
    82  	}
    83  
    84  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
    85  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
    86  	}
    87  
    88  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
    89  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
    90  	}
    91  }
    92  
    93  // For region ap-northeast-1 with FIPS disabled and DualStack disabled
    94  func TestEndpointCase2(t *testing.T) {
    95  	var params = EndpointParameters{
    96  		Region:       ptr.String("ap-northeast-1"),
    97  		UseFIPS:      ptr.Bool(false),
    98  		UseDualStack: ptr.Bool(false),
    99  	}
   100  
   101  	resolver := NewDefaultEndpointResolverV2()
   102  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   103  	_, _ = result, err
   104  
   105  	if err != nil {
   106  		t.Fatalf("expect no error, got %v", err)
   107  	}
   108  
   109  	uri, _ := url.Parse("https://sts.ap-northeast-1.amazonaws.com")
   110  
   111  	expectEndpoint := smithyendpoints.Endpoint{
   112  		URI:        *uri,
   113  		Headers:    http.Header{},
   114  		Properties: smithy.Properties{},
   115  	}
   116  
   117  	if e, a := expectEndpoint.URI, result.URI; e != a {
   118  		t.Errorf("expect %v URI, got %v", e, a)
   119  	}
   120  
   121  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   122  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   123  	}
   124  
   125  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   126  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   127  	}
   128  }
   129  
   130  // For region ap-northeast-2 with FIPS disabled and DualStack disabled
   131  func TestEndpointCase3(t *testing.T) {
   132  	var params = EndpointParameters{
   133  		Region:       ptr.String("ap-northeast-2"),
   134  		UseFIPS:      ptr.Bool(false),
   135  		UseDualStack: ptr.Bool(false),
   136  	}
   137  
   138  	resolver := NewDefaultEndpointResolverV2()
   139  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   140  	_, _ = result, err
   141  
   142  	if err != nil {
   143  		t.Fatalf("expect no error, got %v", err)
   144  	}
   145  
   146  	uri, _ := url.Parse("https://sts.ap-northeast-2.amazonaws.com")
   147  
   148  	expectEndpoint := smithyendpoints.Endpoint{
   149  		URI:        *uri,
   150  		Headers:    http.Header{},
   151  		Properties: smithy.Properties{},
   152  	}
   153  
   154  	if e, a := expectEndpoint.URI, result.URI; e != a {
   155  		t.Errorf("expect %v URI, got %v", e, a)
   156  	}
   157  
   158  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   159  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   160  	}
   161  
   162  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   163  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   164  	}
   165  }
   166  
   167  // For region ap-northeast-3 with FIPS disabled and DualStack disabled
   168  func TestEndpointCase4(t *testing.T) {
   169  	var params = EndpointParameters{
   170  		Region:       ptr.String("ap-northeast-3"),
   171  		UseFIPS:      ptr.Bool(false),
   172  		UseDualStack: ptr.Bool(false),
   173  	}
   174  
   175  	resolver := NewDefaultEndpointResolverV2()
   176  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   177  	_, _ = result, err
   178  
   179  	if err != nil {
   180  		t.Fatalf("expect no error, got %v", err)
   181  	}
   182  
   183  	uri, _ := url.Parse("https://sts.ap-northeast-3.amazonaws.com")
   184  
   185  	expectEndpoint := smithyendpoints.Endpoint{
   186  		URI:        *uri,
   187  		Headers:    http.Header{},
   188  		Properties: smithy.Properties{},
   189  	}
   190  
   191  	if e, a := expectEndpoint.URI, result.URI; e != a {
   192  		t.Errorf("expect %v URI, got %v", e, a)
   193  	}
   194  
   195  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   196  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   197  	}
   198  
   199  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   200  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   201  	}
   202  }
   203  
   204  // For region ap-south-1 with FIPS disabled and DualStack disabled
   205  func TestEndpointCase5(t *testing.T) {
   206  	var params = EndpointParameters{
   207  		Region:       ptr.String("ap-south-1"),
   208  		UseFIPS:      ptr.Bool(false),
   209  		UseDualStack: ptr.Bool(false),
   210  	}
   211  
   212  	resolver := NewDefaultEndpointResolverV2()
   213  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   214  	_, _ = result, err
   215  
   216  	if err != nil {
   217  		t.Fatalf("expect no error, got %v", err)
   218  	}
   219  
   220  	uri, _ := url.Parse("https://sts.ap-south-1.amazonaws.com")
   221  
   222  	expectEndpoint := smithyendpoints.Endpoint{
   223  		URI:        *uri,
   224  		Headers:    http.Header{},
   225  		Properties: smithy.Properties{},
   226  	}
   227  
   228  	if e, a := expectEndpoint.URI, result.URI; e != a {
   229  		t.Errorf("expect %v URI, got %v", e, a)
   230  	}
   231  
   232  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   233  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   234  	}
   235  
   236  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   237  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   238  	}
   239  }
   240  
   241  // For region ap-southeast-1 with FIPS disabled and DualStack disabled
   242  func TestEndpointCase6(t *testing.T) {
   243  	var params = EndpointParameters{
   244  		Region:       ptr.String("ap-southeast-1"),
   245  		UseFIPS:      ptr.Bool(false),
   246  		UseDualStack: ptr.Bool(false),
   247  	}
   248  
   249  	resolver := NewDefaultEndpointResolverV2()
   250  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   251  	_, _ = result, err
   252  
   253  	if err != nil {
   254  		t.Fatalf("expect no error, got %v", err)
   255  	}
   256  
   257  	uri, _ := url.Parse("https://sts.ap-southeast-1.amazonaws.com")
   258  
   259  	expectEndpoint := smithyendpoints.Endpoint{
   260  		URI:        *uri,
   261  		Headers:    http.Header{},
   262  		Properties: smithy.Properties{},
   263  	}
   264  
   265  	if e, a := expectEndpoint.URI, result.URI; e != a {
   266  		t.Errorf("expect %v URI, got %v", e, a)
   267  	}
   268  
   269  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   270  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   271  	}
   272  
   273  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   274  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   275  	}
   276  }
   277  
   278  // For region ap-southeast-2 with FIPS disabled and DualStack disabled
   279  func TestEndpointCase7(t *testing.T) {
   280  	var params = EndpointParameters{
   281  		Region:       ptr.String("ap-southeast-2"),
   282  		UseFIPS:      ptr.Bool(false),
   283  		UseDualStack: ptr.Bool(false),
   284  	}
   285  
   286  	resolver := NewDefaultEndpointResolverV2()
   287  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   288  	_, _ = result, err
   289  
   290  	if err != nil {
   291  		t.Fatalf("expect no error, got %v", err)
   292  	}
   293  
   294  	uri, _ := url.Parse("https://sts.ap-southeast-2.amazonaws.com")
   295  
   296  	expectEndpoint := smithyendpoints.Endpoint{
   297  		URI:        *uri,
   298  		Headers:    http.Header{},
   299  		Properties: smithy.Properties{},
   300  	}
   301  
   302  	if e, a := expectEndpoint.URI, result.URI; e != a {
   303  		t.Errorf("expect %v URI, got %v", e, a)
   304  	}
   305  
   306  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   307  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   308  	}
   309  
   310  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   311  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   312  	}
   313  }
   314  
   315  // For region ap-southeast-3 with FIPS disabled and DualStack disabled
   316  func TestEndpointCase8(t *testing.T) {
   317  	var params = EndpointParameters{
   318  		Region:       ptr.String("ap-southeast-3"),
   319  		UseFIPS:      ptr.Bool(false),
   320  		UseDualStack: ptr.Bool(false),
   321  	}
   322  
   323  	resolver := NewDefaultEndpointResolverV2()
   324  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   325  	_, _ = result, err
   326  
   327  	if err != nil {
   328  		t.Fatalf("expect no error, got %v", err)
   329  	}
   330  
   331  	uri, _ := url.Parse("https://sts.ap-southeast-3.amazonaws.com")
   332  
   333  	expectEndpoint := smithyendpoints.Endpoint{
   334  		URI:        *uri,
   335  		Headers:    http.Header{},
   336  		Properties: smithy.Properties{},
   337  	}
   338  
   339  	if e, a := expectEndpoint.URI, result.URI; e != a {
   340  		t.Errorf("expect %v URI, got %v", e, a)
   341  	}
   342  
   343  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   344  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   345  	}
   346  
   347  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   348  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   349  	}
   350  }
   351  
   352  // For region aws-global with FIPS disabled and DualStack disabled
   353  func TestEndpointCase9(t *testing.T) {
   354  	var params = EndpointParameters{
   355  		Region:       ptr.String("aws-global"),
   356  		UseFIPS:      ptr.Bool(false),
   357  		UseDualStack: ptr.Bool(false),
   358  	}
   359  
   360  	resolver := NewDefaultEndpointResolverV2()
   361  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   362  	_, _ = result, err
   363  
   364  	if err != nil {
   365  		t.Fatalf("expect no error, got %v", err)
   366  	}
   367  
   368  	uri, _ := url.Parse("https://sts.amazonaws.com")
   369  
   370  	expectEndpoint := smithyendpoints.Endpoint{
   371  		URI:     *uri,
   372  		Headers: http.Header{},
   373  		Properties: func() smithy.Properties {
   374  			var out smithy.Properties
   375  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
   376  				{
   377  					SchemeID: "aws.auth#sigv4",
   378  					SignerProperties: func() smithy.Properties {
   379  						var sp smithy.Properties
   380  						smithyhttp.SetSigV4SigningName(&sp, "sts")
   381  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
   382  
   383  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
   384  						return sp
   385  					}(),
   386  				},
   387  			})
   388  			return out
   389  		}(),
   390  	}
   391  
   392  	if e, a := expectEndpoint.URI, result.URI; e != a {
   393  		t.Errorf("expect %v URI, got %v", e, a)
   394  	}
   395  
   396  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   397  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   398  	}
   399  
   400  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   401  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   402  	}
   403  }
   404  
   405  // For region ca-central-1 with FIPS disabled and DualStack disabled
   406  func TestEndpointCase10(t *testing.T) {
   407  	var params = EndpointParameters{
   408  		Region:       ptr.String("ca-central-1"),
   409  		UseFIPS:      ptr.Bool(false),
   410  		UseDualStack: ptr.Bool(false),
   411  	}
   412  
   413  	resolver := NewDefaultEndpointResolverV2()
   414  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   415  	_, _ = result, err
   416  
   417  	if err != nil {
   418  		t.Fatalf("expect no error, got %v", err)
   419  	}
   420  
   421  	uri, _ := url.Parse("https://sts.ca-central-1.amazonaws.com")
   422  
   423  	expectEndpoint := smithyendpoints.Endpoint{
   424  		URI:        *uri,
   425  		Headers:    http.Header{},
   426  		Properties: smithy.Properties{},
   427  	}
   428  
   429  	if e, a := expectEndpoint.URI, result.URI; e != a {
   430  		t.Errorf("expect %v URI, got %v", e, a)
   431  	}
   432  
   433  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   434  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   435  	}
   436  
   437  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   438  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   439  	}
   440  }
   441  
   442  // For region eu-central-1 with FIPS disabled and DualStack disabled
   443  func TestEndpointCase11(t *testing.T) {
   444  	var params = EndpointParameters{
   445  		Region:       ptr.String("eu-central-1"),
   446  		UseFIPS:      ptr.Bool(false),
   447  		UseDualStack: ptr.Bool(false),
   448  	}
   449  
   450  	resolver := NewDefaultEndpointResolverV2()
   451  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   452  	_, _ = result, err
   453  
   454  	if err != nil {
   455  		t.Fatalf("expect no error, got %v", err)
   456  	}
   457  
   458  	uri, _ := url.Parse("https://sts.eu-central-1.amazonaws.com")
   459  
   460  	expectEndpoint := smithyendpoints.Endpoint{
   461  		URI:        *uri,
   462  		Headers:    http.Header{},
   463  		Properties: smithy.Properties{},
   464  	}
   465  
   466  	if e, a := expectEndpoint.URI, result.URI; e != a {
   467  		t.Errorf("expect %v URI, got %v", e, a)
   468  	}
   469  
   470  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   471  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   472  	}
   473  
   474  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   475  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   476  	}
   477  }
   478  
   479  // For region eu-north-1 with FIPS disabled and DualStack disabled
   480  func TestEndpointCase12(t *testing.T) {
   481  	var params = EndpointParameters{
   482  		Region:       ptr.String("eu-north-1"),
   483  		UseFIPS:      ptr.Bool(false),
   484  		UseDualStack: ptr.Bool(false),
   485  	}
   486  
   487  	resolver := NewDefaultEndpointResolverV2()
   488  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   489  	_, _ = result, err
   490  
   491  	if err != nil {
   492  		t.Fatalf("expect no error, got %v", err)
   493  	}
   494  
   495  	uri, _ := url.Parse("https://sts.eu-north-1.amazonaws.com")
   496  
   497  	expectEndpoint := smithyendpoints.Endpoint{
   498  		URI:        *uri,
   499  		Headers:    http.Header{},
   500  		Properties: smithy.Properties{},
   501  	}
   502  
   503  	if e, a := expectEndpoint.URI, result.URI; e != a {
   504  		t.Errorf("expect %v URI, got %v", e, a)
   505  	}
   506  
   507  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   508  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   509  	}
   510  
   511  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   512  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   513  	}
   514  }
   515  
   516  // For region eu-south-1 with FIPS disabled and DualStack disabled
   517  func TestEndpointCase13(t *testing.T) {
   518  	var params = EndpointParameters{
   519  		Region:       ptr.String("eu-south-1"),
   520  		UseFIPS:      ptr.Bool(false),
   521  		UseDualStack: ptr.Bool(false),
   522  	}
   523  
   524  	resolver := NewDefaultEndpointResolverV2()
   525  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   526  	_, _ = result, err
   527  
   528  	if err != nil {
   529  		t.Fatalf("expect no error, got %v", err)
   530  	}
   531  
   532  	uri, _ := url.Parse("https://sts.eu-south-1.amazonaws.com")
   533  
   534  	expectEndpoint := smithyendpoints.Endpoint{
   535  		URI:        *uri,
   536  		Headers:    http.Header{},
   537  		Properties: smithy.Properties{},
   538  	}
   539  
   540  	if e, a := expectEndpoint.URI, result.URI; e != a {
   541  		t.Errorf("expect %v URI, got %v", e, a)
   542  	}
   543  
   544  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   545  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   546  	}
   547  
   548  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   549  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   550  	}
   551  }
   552  
   553  // For region eu-west-1 with FIPS disabled and DualStack disabled
   554  func TestEndpointCase14(t *testing.T) {
   555  	var params = EndpointParameters{
   556  		Region:       ptr.String("eu-west-1"),
   557  		UseFIPS:      ptr.Bool(false),
   558  		UseDualStack: ptr.Bool(false),
   559  	}
   560  
   561  	resolver := NewDefaultEndpointResolverV2()
   562  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   563  	_, _ = result, err
   564  
   565  	if err != nil {
   566  		t.Fatalf("expect no error, got %v", err)
   567  	}
   568  
   569  	uri, _ := url.Parse("https://sts.eu-west-1.amazonaws.com")
   570  
   571  	expectEndpoint := smithyendpoints.Endpoint{
   572  		URI:        *uri,
   573  		Headers:    http.Header{},
   574  		Properties: smithy.Properties{},
   575  	}
   576  
   577  	if e, a := expectEndpoint.URI, result.URI; e != a {
   578  		t.Errorf("expect %v URI, got %v", e, a)
   579  	}
   580  
   581  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   582  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   583  	}
   584  
   585  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   586  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   587  	}
   588  }
   589  
   590  // For region eu-west-2 with FIPS disabled and DualStack disabled
   591  func TestEndpointCase15(t *testing.T) {
   592  	var params = EndpointParameters{
   593  		Region:       ptr.String("eu-west-2"),
   594  		UseFIPS:      ptr.Bool(false),
   595  		UseDualStack: ptr.Bool(false),
   596  	}
   597  
   598  	resolver := NewDefaultEndpointResolverV2()
   599  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   600  	_, _ = result, err
   601  
   602  	if err != nil {
   603  		t.Fatalf("expect no error, got %v", err)
   604  	}
   605  
   606  	uri, _ := url.Parse("https://sts.eu-west-2.amazonaws.com")
   607  
   608  	expectEndpoint := smithyendpoints.Endpoint{
   609  		URI:        *uri,
   610  		Headers:    http.Header{},
   611  		Properties: smithy.Properties{},
   612  	}
   613  
   614  	if e, a := expectEndpoint.URI, result.URI; e != a {
   615  		t.Errorf("expect %v URI, got %v", e, a)
   616  	}
   617  
   618  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   619  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   620  	}
   621  
   622  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   623  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   624  	}
   625  }
   626  
   627  // For region eu-west-3 with FIPS disabled and DualStack disabled
   628  func TestEndpointCase16(t *testing.T) {
   629  	var params = EndpointParameters{
   630  		Region:       ptr.String("eu-west-3"),
   631  		UseFIPS:      ptr.Bool(false),
   632  		UseDualStack: ptr.Bool(false),
   633  	}
   634  
   635  	resolver := NewDefaultEndpointResolverV2()
   636  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   637  	_, _ = result, err
   638  
   639  	if err != nil {
   640  		t.Fatalf("expect no error, got %v", err)
   641  	}
   642  
   643  	uri, _ := url.Parse("https://sts.eu-west-3.amazonaws.com")
   644  
   645  	expectEndpoint := smithyendpoints.Endpoint{
   646  		URI:        *uri,
   647  		Headers:    http.Header{},
   648  		Properties: smithy.Properties{},
   649  	}
   650  
   651  	if e, a := expectEndpoint.URI, result.URI; e != a {
   652  		t.Errorf("expect %v URI, got %v", e, a)
   653  	}
   654  
   655  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   656  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   657  	}
   658  
   659  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   660  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   661  	}
   662  }
   663  
   664  // For region me-south-1 with FIPS disabled and DualStack disabled
   665  func TestEndpointCase17(t *testing.T) {
   666  	var params = EndpointParameters{
   667  		Region:       ptr.String("me-south-1"),
   668  		UseFIPS:      ptr.Bool(false),
   669  		UseDualStack: ptr.Bool(false),
   670  	}
   671  
   672  	resolver := NewDefaultEndpointResolverV2()
   673  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   674  	_, _ = result, err
   675  
   676  	if err != nil {
   677  		t.Fatalf("expect no error, got %v", err)
   678  	}
   679  
   680  	uri, _ := url.Parse("https://sts.me-south-1.amazonaws.com")
   681  
   682  	expectEndpoint := smithyendpoints.Endpoint{
   683  		URI:        *uri,
   684  		Headers:    http.Header{},
   685  		Properties: smithy.Properties{},
   686  	}
   687  
   688  	if e, a := expectEndpoint.URI, result.URI; e != a {
   689  		t.Errorf("expect %v URI, got %v", e, a)
   690  	}
   691  
   692  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   693  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   694  	}
   695  
   696  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   697  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   698  	}
   699  }
   700  
   701  // For region sa-east-1 with FIPS disabled and DualStack disabled
   702  func TestEndpointCase18(t *testing.T) {
   703  	var params = EndpointParameters{
   704  		Region:       ptr.String("sa-east-1"),
   705  		UseFIPS:      ptr.Bool(false),
   706  		UseDualStack: ptr.Bool(false),
   707  	}
   708  
   709  	resolver := NewDefaultEndpointResolverV2()
   710  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   711  	_, _ = result, err
   712  
   713  	if err != nil {
   714  		t.Fatalf("expect no error, got %v", err)
   715  	}
   716  
   717  	uri, _ := url.Parse("https://sts.sa-east-1.amazonaws.com")
   718  
   719  	expectEndpoint := smithyendpoints.Endpoint{
   720  		URI:        *uri,
   721  		Headers:    http.Header{},
   722  		Properties: smithy.Properties{},
   723  	}
   724  
   725  	if e, a := expectEndpoint.URI, result.URI; e != a {
   726  		t.Errorf("expect %v URI, got %v", e, a)
   727  	}
   728  
   729  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   730  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   731  	}
   732  
   733  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   734  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   735  	}
   736  }
   737  
   738  // For region us-east-1 with FIPS disabled and DualStack disabled
   739  func TestEndpointCase19(t *testing.T) {
   740  	var params = EndpointParameters{
   741  		Region:       ptr.String("us-east-1"),
   742  		UseFIPS:      ptr.Bool(false),
   743  		UseDualStack: ptr.Bool(false),
   744  	}
   745  
   746  	resolver := NewDefaultEndpointResolverV2()
   747  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   748  	_, _ = result, err
   749  
   750  	if err != nil {
   751  		t.Fatalf("expect no error, got %v", err)
   752  	}
   753  
   754  	uri, _ := url.Parse("https://sts.us-east-1.amazonaws.com")
   755  
   756  	expectEndpoint := smithyendpoints.Endpoint{
   757  		URI:        *uri,
   758  		Headers:    http.Header{},
   759  		Properties: smithy.Properties{},
   760  	}
   761  
   762  	if e, a := expectEndpoint.URI, result.URI; e != a {
   763  		t.Errorf("expect %v URI, got %v", e, a)
   764  	}
   765  
   766  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   767  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   768  	}
   769  
   770  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   771  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   772  	}
   773  }
   774  
   775  // For region us-east-1 with FIPS enabled and DualStack disabled
   776  func TestEndpointCase20(t *testing.T) {
   777  	var params = EndpointParameters{
   778  		Region:       ptr.String("us-east-1"),
   779  		UseFIPS:      ptr.Bool(true),
   780  		UseDualStack: ptr.Bool(false),
   781  	}
   782  
   783  	resolver := NewDefaultEndpointResolverV2()
   784  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   785  	_, _ = result, err
   786  
   787  	if err != nil {
   788  		t.Fatalf("expect no error, got %v", err)
   789  	}
   790  
   791  	uri, _ := url.Parse("https://sts-fips.us-east-1.amazonaws.com")
   792  
   793  	expectEndpoint := smithyendpoints.Endpoint{
   794  		URI:        *uri,
   795  		Headers:    http.Header{},
   796  		Properties: smithy.Properties{},
   797  	}
   798  
   799  	if e, a := expectEndpoint.URI, result.URI; e != a {
   800  		t.Errorf("expect %v URI, got %v", e, a)
   801  	}
   802  
   803  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   804  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   805  	}
   806  
   807  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   808  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   809  	}
   810  }
   811  
   812  // For region us-east-2 with FIPS disabled and DualStack disabled
   813  func TestEndpointCase21(t *testing.T) {
   814  	var params = EndpointParameters{
   815  		Region:       ptr.String("us-east-2"),
   816  		UseFIPS:      ptr.Bool(false),
   817  		UseDualStack: ptr.Bool(false),
   818  	}
   819  
   820  	resolver := NewDefaultEndpointResolverV2()
   821  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   822  	_, _ = result, err
   823  
   824  	if err != nil {
   825  		t.Fatalf("expect no error, got %v", err)
   826  	}
   827  
   828  	uri, _ := url.Parse("https://sts.us-east-2.amazonaws.com")
   829  
   830  	expectEndpoint := smithyendpoints.Endpoint{
   831  		URI:        *uri,
   832  		Headers:    http.Header{},
   833  		Properties: smithy.Properties{},
   834  	}
   835  
   836  	if e, a := expectEndpoint.URI, result.URI; e != a {
   837  		t.Errorf("expect %v URI, got %v", e, a)
   838  	}
   839  
   840  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   841  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   842  	}
   843  
   844  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   845  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   846  	}
   847  }
   848  
   849  // For region us-east-2 with FIPS enabled and DualStack disabled
   850  func TestEndpointCase22(t *testing.T) {
   851  	var params = EndpointParameters{
   852  		Region:       ptr.String("us-east-2"),
   853  		UseFIPS:      ptr.Bool(true),
   854  		UseDualStack: ptr.Bool(false),
   855  	}
   856  
   857  	resolver := NewDefaultEndpointResolverV2()
   858  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   859  	_, _ = result, err
   860  
   861  	if err != nil {
   862  		t.Fatalf("expect no error, got %v", err)
   863  	}
   864  
   865  	uri, _ := url.Parse("https://sts-fips.us-east-2.amazonaws.com")
   866  
   867  	expectEndpoint := smithyendpoints.Endpoint{
   868  		URI:        *uri,
   869  		Headers:    http.Header{},
   870  		Properties: smithy.Properties{},
   871  	}
   872  
   873  	if e, a := expectEndpoint.URI, result.URI; e != a {
   874  		t.Errorf("expect %v URI, got %v", e, a)
   875  	}
   876  
   877  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   878  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   879  	}
   880  
   881  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   882  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   883  	}
   884  }
   885  
   886  // For region us-west-1 with FIPS disabled and DualStack disabled
   887  func TestEndpointCase23(t *testing.T) {
   888  	var params = EndpointParameters{
   889  		Region:       ptr.String("us-west-1"),
   890  		UseFIPS:      ptr.Bool(false),
   891  		UseDualStack: ptr.Bool(false),
   892  	}
   893  
   894  	resolver := NewDefaultEndpointResolverV2()
   895  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   896  	_, _ = result, err
   897  
   898  	if err != nil {
   899  		t.Fatalf("expect no error, got %v", err)
   900  	}
   901  
   902  	uri, _ := url.Parse("https://sts.us-west-1.amazonaws.com")
   903  
   904  	expectEndpoint := smithyendpoints.Endpoint{
   905  		URI:        *uri,
   906  		Headers:    http.Header{},
   907  		Properties: smithy.Properties{},
   908  	}
   909  
   910  	if e, a := expectEndpoint.URI, result.URI; e != a {
   911  		t.Errorf("expect %v URI, got %v", e, a)
   912  	}
   913  
   914  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   915  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   916  	}
   917  
   918  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   919  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   920  	}
   921  }
   922  
   923  // For region us-west-1 with FIPS enabled and DualStack disabled
   924  func TestEndpointCase24(t *testing.T) {
   925  	var params = EndpointParameters{
   926  		Region:       ptr.String("us-west-1"),
   927  		UseFIPS:      ptr.Bool(true),
   928  		UseDualStack: ptr.Bool(false),
   929  	}
   930  
   931  	resolver := NewDefaultEndpointResolverV2()
   932  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   933  	_, _ = result, err
   934  
   935  	if err != nil {
   936  		t.Fatalf("expect no error, got %v", err)
   937  	}
   938  
   939  	uri, _ := url.Parse("https://sts-fips.us-west-1.amazonaws.com")
   940  
   941  	expectEndpoint := smithyendpoints.Endpoint{
   942  		URI:        *uri,
   943  		Headers:    http.Header{},
   944  		Properties: smithy.Properties{},
   945  	}
   946  
   947  	if e, a := expectEndpoint.URI, result.URI; e != a {
   948  		t.Errorf("expect %v URI, got %v", e, a)
   949  	}
   950  
   951  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   952  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   953  	}
   954  
   955  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   956  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   957  	}
   958  }
   959  
   960  // For region us-west-2 with FIPS disabled and DualStack disabled
   961  func TestEndpointCase25(t *testing.T) {
   962  	var params = EndpointParameters{
   963  		Region:       ptr.String("us-west-2"),
   964  		UseFIPS:      ptr.Bool(false),
   965  		UseDualStack: ptr.Bool(false),
   966  	}
   967  
   968  	resolver := NewDefaultEndpointResolverV2()
   969  	result, err := resolver.ResolveEndpoint(context.Background(), params)
   970  	_, _ = result, err
   971  
   972  	if err != nil {
   973  		t.Fatalf("expect no error, got %v", err)
   974  	}
   975  
   976  	uri, _ := url.Parse("https://sts.us-west-2.amazonaws.com")
   977  
   978  	expectEndpoint := smithyendpoints.Endpoint{
   979  		URI:        *uri,
   980  		Headers:    http.Header{},
   981  		Properties: smithy.Properties{},
   982  	}
   983  
   984  	if e, a := expectEndpoint.URI, result.URI; e != a {
   985  		t.Errorf("expect %v URI, got %v", e, a)
   986  	}
   987  
   988  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
   989  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
   990  	}
   991  
   992  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
   993  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
   994  	}
   995  }
   996  
   997  // For region us-west-2 with FIPS enabled and DualStack disabled
   998  func TestEndpointCase26(t *testing.T) {
   999  	var params = EndpointParameters{
  1000  		Region:       ptr.String("us-west-2"),
  1001  		UseFIPS:      ptr.Bool(true),
  1002  		UseDualStack: ptr.Bool(false),
  1003  	}
  1004  
  1005  	resolver := NewDefaultEndpointResolverV2()
  1006  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1007  	_, _ = result, err
  1008  
  1009  	if err != nil {
  1010  		t.Fatalf("expect no error, got %v", err)
  1011  	}
  1012  
  1013  	uri, _ := url.Parse("https://sts-fips.us-west-2.amazonaws.com")
  1014  
  1015  	expectEndpoint := smithyendpoints.Endpoint{
  1016  		URI:        *uri,
  1017  		Headers:    http.Header{},
  1018  		Properties: smithy.Properties{},
  1019  	}
  1020  
  1021  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1022  		t.Errorf("expect %v URI, got %v", e, a)
  1023  	}
  1024  
  1025  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1026  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1027  	}
  1028  
  1029  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1030  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1031  	}
  1032  }
  1033  
  1034  // For region us-east-1 with FIPS enabled and DualStack enabled
  1035  func TestEndpointCase27(t *testing.T) {
  1036  	var params = EndpointParameters{
  1037  		Region:       ptr.String("us-east-1"),
  1038  		UseFIPS:      ptr.Bool(true),
  1039  		UseDualStack: ptr.Bool(true),
  1040  	}
  1041  
  1042  	resolver := NewDefaultEndpointResolverV2()
  1043  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1044  	_, _ = result, err
  1045  
  1046  	if err != nil {
  1047  		t.Fatalf("expect no error, got %v", err)
  1048  	}
  1049  
  1050  	uri, _ := url.Parse("https://sts-fips.us-east-1.api.aws")
  1051  
  1052  	expectEndpoint := smithyendpoints.Endpoint{
  1053  		URI:        *uri,
  1054  		Headers:    http.Header{},
  1055  		Properties: smithy.Properties{},
  1056  	}
  1057  
  1058  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1059  		t.Errorf("expect %v URI, got %v", e, a)
  1060  	}
  1061  
  1062  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1063  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1064  	}
  1065  
  1066  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1067  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1068  	}
  1069  }
  1070  
  1071  // For region us-east-1 with FIPS disabled and DualStack enabled
  1072  func TestEndpointCase28(t *testing.T) {
  1073  	var params = EndpointParameters{
  1074  		Region:       ptr.String("us-east-1"),
  1075  		UseFIPS:      ptr.Bool(false),
  1076  		UseDualStack: ptr.Bool(true),
  1077  	}
  1078  
  1079  	resolver := NewDefaultEndpointResolverV2()
  1080  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1081  	_, _ = result, err
  1082  
  1083  	if err != nil {
  1084  		t.Fatalf("expect no error, got %v", err)
  1085  	}
  1086  
  1087  	uri, _ := url.Parse("https://sts.us-east-1.api.aws")
  1088  
  1089  	expectEndpoint := smithyendpoints.Endpoint{
  1090  		URI:        *uri,
  1091  		Headers:    http.Header{},
  1092  		Properties: smithy.Properties{},
  1093  	}
  1094  
  1095  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1096  		t.Errorf("expect %v URI, got %v", e, a)
  1097  	}
  1098  
  1099  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1100  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1101  	}
  1102  
  1103  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1104  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1105  	}
  1106  }
  1107  
  1108  // For region cn-north-1 with FIPS disabled and DualStack disabled
  1109  func TestEndpointCase29(t *testing.T) {
  1110  	var params = EndpointParameters{
  1111  		Region:       ptr.String("cn-north-1"),
  1112  		UseFIPS:      ptr.Bool(false),
  1113  		UseDualStack: ptr.Bool(false),
  1114  	}
  1115  
  1116  	resolver := NewDefaultEndpointResolverV2()
  1117  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1118  	_, _ = result, err
  1119  
  1120  	if err != nil {
  1121  		t.Fatalf("expect no error, got %v", err)
  1122  	}
  1123  
  1124  	uri, _ := url.Parse("https://sts.cn-north-1.amazonaws.com.cn")
  1125  
  1126  	expectEndpoint := smithyendpoints.Endpoint{
  1127  		URI:        *uri,
  1128  		Headers:    http.Header{},
  1129  		Properties: smithy.Properties{},
  1130  	}
  1131  
  1132  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1133  		t.Errorf("expect %v URI, got %v", e, a)
  1134  	}
  1135  
  1136  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1137  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1138  	}
  1139  
  1140  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1141  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1142  	}
  1143  }
  1144  
  1145  // For region cn-northwest-1 with FIPS disabled and DualStack disabled
  1146  func TestEndpointCase30(t *testing.T) {
  1147  	var params = EndpointParameters{
  1148  		Region:       ptr.String("cn-northwest-1"),
  1149  		UseFIPS:      ptr.Bool(false),
  1150  		UseDualStack: ptr.Bool(false),
  1151  	}
  1152  
  1153  	resolver := NewDefaultEndpointResolverV2()
  1154  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1155  	_, _ = result, err
  1156  
  1157  	if err != nil {
  1158  		t.Fatalf("expect no error, got %v", err)
  1159  	}
  1160  
  1161  	uri, _ := url.Parse("https://sts.cn-northwest-1.amazonaws.com.cn")
  1162  
  1163  	expectEndpoint := smithyendpoints.Endpoint{
  1164  		URI:        *uri,
  1165  		Headers:    http.Header{},
  1166  		Properties: smithy.Properties{},
  1167  	}
  1168  
  1169  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1170  		t.Errorf("expect %v URI, got %v", e, a)
  1171  	}
  1172  
  1173  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1174  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1175  	}
  1176  
  1177  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1178  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1179  	}
  1180  }
  1181  
  1182  // For region cn-north-1 with FIPS enabled and DualStack enabled
  1183  func TestEndpointCase31(t *testing.T) {
  1184  	var params = EndpointParameters{
  1185  		Region:       ptr.String("cn-north-1"),
  1186  		UseFIPS:      ptr.Bool(true),
  1187  		UseDualStack: ptr.Bool(true),
  1188  	}
  1189  
  1190  	resolver := NewDefaultEndpointResolverV2()
  1191  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1192  	_, _ = result, err
  1193  
  1194  	if err != nil {
  1195  		t.Fatalf("expect no error, got %v", err)
  1196  	}
  1197  
  1198  	uri, _ := url.Parse("https://sts-fips.cn-north-1.api.amazonwebservices.com.cn")
  1199  
  1200  	expectEndpoint := smithyendpoints.Endpoint{
  1201  		URI:        *uri,
  1202  		Headers:    http.Header{},
  1203  		Properties: smithy.Properties{},
  1204  	}
  1205  
  1206  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1207  		t.Errorf("expect %v URI, got %v", e, a)
  1208  	}
  1209  
  1210  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1211  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1212  	}
  1213  
  1214  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1215  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1216  	}
  1217  }
  1218  
  1219  // For region cn-north-1 with FIPS enabled and DualStack disabled
  1220  func TestEndpointCase32(t *testing.T) {
  1221  	var params = EndpointParameters{
  1222  		Region:       ptr.String("cn-north-1"),
  1223  		UseFIPS:      ptr.Bool(true),
  1224  		UseDualStack: ptr.Bool(false),
  1225  	}
  1226  
  1227  	resolver := NewDefaultEndpointResolverV2()
  1228  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1229  	_, _ = result, err
  1230  
  1231  	if err != nil {
  1232  		t.Fatalf("expect no error, got %v", err)
  1233  	}
  1234  
  1235  	uri, _ := url.Parse("https://sts-fips.cn-north-1.amazonaws.com.cn")
  1236  
  1237  	expectEndpoint := smithyendpoints.Endpoint{
  1238  		URI:        *uri,
  1239  		Headers:    http.Header{},
  1240  		Properties: smithy.Properties{},
  1241  	}
  1242  
  1243  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1244  		t.Errorf("expect %v URI, got %v", e, a)
  1245  	}
  1246  
  1247  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1248  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1249  	}
  1250  
  1251  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1252  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1253  	}
  1254  }
  1255  
  1256  // For region cn-north-1 with FIPS disabled and DualStack enabled
  1257  func TestEndpointCase33(t *testing.T) {
  1258  	var params = EndpointParameters{
  1259  		Region:       ptr.String("cn-north-1"),
  1260  		UseFIPS:      ptr.Bool(false),
  1261  		UseDualStack: ptr.Bool(true),
  1262  	}
  1263  
  1264  	resolver := NewDefaultEndpointResolverV2()
  1265  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1266  	_, _ = result, err
  1267  
  1268  	if err != nil {
  1269  		t.Fatalf("expect no error, got %v", err)
  1270  	}
  1271  
  1272  	uri, _ := url.Parse("https://sts.cn-north-1.api.amazonwebservices.com.cn")
  1273  
  1274  	expectEndpoint := smithyendpoints.Endpoint{
  1275  		URI:        *uri,
  1276  		Headers:    http.Header{},
  1277  		Properties: smithy.Properties{},
  1278  	}
  1279  
  1280  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1281  		t.Errorf("expect %v URI, got %v", e, a)
  1282  	}
  1283  
  1284  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1285  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1286  	}
  1287  
  1288  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1289  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1290  	}
  1291  }
  1292  
  1293  // For region us-gov-east-1 with FIPS disabled and DualStack disabled
  1294  func TestEndpointCase34(t *testing.T) {
  1295  	var params = EndpointParameters{
  1296  		Region:       ptr.String("us-gov-east-1"),
  1297  		UseFIPS:      ptr.Bool(false),
  1298  		UseDualStack: ptr.Bool(false),
  1299  	}
  1300  
  1301  	resolver := NewDefaultEndpointResolverV2()
  1302  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1303  	_, _ = result, err
  1304  
  1305  	if err != nil {
  1306  		t.Fatalf("expect no error, got %v", err)
  1307  	}
  1308  
  1309  	uri, _ := url.Parse("https://sts.us-gov-east-1.amazonaws.com")
  1310  
  1311  	expectEndpoint := smithyendpoints.Endpoint{
  1312  		URI:        *uri,
  1313  		Headers:    http.Header{},
  1314  		Properties: smithy.Properties{},
  1315  	}
  1316  
  1317  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1318  		t.Errorf("expect %v URI, got %v", e, a)
  1319  	}
  1320  
  1321  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1322  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1323  	}
  1324  
  1325  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1326  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1327  	}
  1328  }
  1329  
  1330  // For region us-gov-east-1 with FIPS enabled and DualStack disabled
  1331  func TestEndpointCase35(t *testing.T) {
  1332  	var params = EndpointParameters{
  1333  		Region:       ptr.String("us-gov-east-1"),
  1334  		UseFIPS:      ptr.Bool(true),
  1335  		UseDualStack: ptr.Bool(false),
  1336  	}
  1337  
  1338  	resolver := NewDefaultEndpointResolverV2()
  1339  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1340  	_, _ = result, err
  1341  
  1342  	if err != nil {
  1343  		t.Fatalf("expect no error, got %v", err)
  1344  	}
  1345  
  1346  	uri, _ := url.Parse("https://sts.us-gov-east-1.amazonaws.com")
  1347  
  1348  	expectEndpoint := smithyendpoints.Endpoint{
  1349  		URI:        *uri,
  1350  		Headers:    http.Header{},
  1351  		Properties: smithy.Properties{},
  1352  	}
  1353  
  1354  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1355  		t.Errorf("expect %v URI, got %v", e, a)
  1356  	}
  1357  
  1358  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1359  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1360  	}
  1361  
  1362  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1363  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1364  	}
  1365  }
  1366  
  1367  // For region us-gov-west-1 with FIPS disabled and DualStack disabled
  1368  func TestEndpointCase36(t *testing.T) {
  1369  	var params = EndpointParameters{
  1370  		Region:       ptr.String("us-gov-west-1"),
  1371  		UseFIPS:      ptr.Bool(false),
  1372  		UseDualStack: ptr.Bool(false),
  1373  	}
  1374  
  1375  	resolver := NewDefaultEndpointResolverV2()
  1376  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1377  	_, _ = result, err
  1378  
  1379  	if err != nil {
  1380  		t.Fatalf("expect no error, got %v", err)
  1381  	}
  1382  
  1383  	uri, _ := url.Parse("https://sts.us-gov-west-1.amazonaws.com")
  1384  
  1385  	expectEndpoint := smithyendpoints.Endpoint{
  1386  		URI:        *uri,
  1387  		Headers:    http.Header{},
  1388  		Properties: smithy.Properties{},
  1389  	}
  1390  
  1391  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1392  		t.Errorf("expect %v URI, got %v", e, a)
  1393  	}
  1394  
  1395  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1396  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1397  	}
  1398  
  1399  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1400  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1401  	}
  1402  }
  1403  
  1404  // For region us-gov-west-1 with FIPS enabled and DualStack disabled
  1405  func TestEndpointCase37(t *testing.T) {
  1406  	var params = EndpointParameters{
  1407  		Region:       ptr.String("us-gov-west-1"),
  1408  		UseFIPS:      ptr.Bool(true),
  1409  		UseDualStack: ptr.Bool(false),
  1410  	}
  1411  
  1412  	resolver := NewDefaultEndpointResolverV2()
  1413  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1414  	_, _ = result, err
  1415  
  1416  	if err != nil {
  1417  		t.Fatalf("expect no error, got %v", err)
  1418  	}
  1419  
  1420  	uri, _ := url.Parse("https://sts.us-gov-west-1.amazonaws.com")
  1421  
  1422  	expectEndpoint := smithyendpoints.Endpoint{
  1423  		URI:        *uri,
  1424  		Headers:    http.Header{},
  1425  		Properties: smithy.Properties{},
  1426  	}
  1427  
  1428  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1429  		t.Errorf("expect %v URI, got %v", e, a)
  1430  	}
  1431  
  1432  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1433  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1434  	}
  1435  
  1436  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1437  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1438  	}
  1439  }
  1440  
  1441  // For region us-gov-east-1 with FIPS enabled and DualStack enabled
  1442  func TestEndpointCase38(t *testing.T) {
  1443  	var params = EndpointParameters{
  1444  		Region:       ptr.String("us-gov-east-1"),
  1445  		UseFIPS:      ptr.Bool(true),
  1446  		UseDualStack: ptr.Bool(true),
  1447  	}
  1448  
  1449  	resolver := NewDefaultEndpointResolverV2()
  1450  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1451  	_, _ = result, err
  1452  
  1453  	if err != nil {
  1454  		t.Fatalf("expect no error, got %v", err)
  1455  	}
  1456  
  1457  	uri, _ := url.Parse("https://sts-fips.us-gov-east-1.api.aws")
  1458  
  1459  	expectEndpoint := smithyendpoints.Endpoint{
  1460  		URI:        *uri,
  1461  		Headers:    http.Header{},
  1462  		Properties: smithy.Properties{},
  1463  	}
  1464  
  1465  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1466  		t.Errorf("expect %v URI, got %v", e, a)
  1467  	}
  1468  
  1469  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1470  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1471  	}
  1472  
  1473  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1474  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1475  	}
  1476  }
  1477  
  1478  // For region us-gov-east-1 with FIPS disabled and DualStack enabled
  1479  func TestEndpointCase39(t *testing.T) {
  1480  	var params = EndpointParameters{
  1481  		Region:       ptr.String("us-gov-east-1"),
  1482  		UseFIPS:      ptr.Bool(false),
  1483  		UseDualStack: ptr.Bool(true),
  1484  	}
  1485  
  1486  	resolver := NewDefaultEndpointResolverV2()
  1487  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1488  	_, _ = result, err
  1489  
  1490  	if err != nil {
  1491  		t.Fatalf("expect no error, got %v", err)
  1492  	}
  1493  
  1494  	uri, _ := url.Parse("https://sts.us-gov-east-1.api.aws")
  1495  
  1496  	expectEndpoint := smithyendpoints.Endpoint{
  1497  		URI:        *uri,
  1498  		Headers:    http.Header{},
  1499  		Properties: smithy.Properties{},
  1500  	}
  1501  
  1502  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1503  		t.Errorf("expect %v URI, got %v", e, a)
  1504  	}
  1505  
  1506  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1507  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1508  	}
  1509  
  1510  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1511  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1512  	}
  1513  }
  1514  
  1515  // For region us-iso-east-1 with FIPS disabled and DualStack disabled
  1516  func TestEndpointCase40(t *testing.T) {
  1517  	var params = EndpointParameters{
  1518  		Region:       ptr.String("us-iso-east-1"),
  1519  		UseFIPS:      ptr.Bool(false),
  1520  		UseDualStack: ptr.Bool(false),
  1521  	}
  1522  
  1523  	resolver := NewDefaultEndpointResolverV2()
  1524  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1525  	_, _ = result, err
  1526  
  1527  	if err != nil {
  1528  		t.Fatalf("expect no error, got %v", err)
  1529  	}
  1530  
  1531  	uri, _ := url.Parse("https://sts.us-iso-east-1.c2s.ic.gov")
  1532  
  1533  	expectEndpoint := smithyendpoints.Endpoint{
  1534  		URI:        *uri,
  1535  		Headers:    http.Header{},
  1536  		Properties: smithy.Properties{},
  1537  	}
  1538  
  1539  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1540  		t.Errorf("expect %v URI, got %v", e, a)
  1541  	}
  1542  
  1543  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1544  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1545  	}
  1546  
  1547  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1548  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1549  	}
  1550  }
  1551  
  1552  // For region us-iso-west-1 with FIPS disabled and DualStack disabled
  1553  func TestEndpointCase41(t *testing.T) {
  1554  	var params = EndpointParameters{
  1555  		Region:       ptr.String("us-iso-west-1"),
  1556  		UseFIPS:      ptr.Bool(false),
  1557  		UseDualStack: ptr.Bool(false),
  1558  	}
  1559  
  1560  	resolver := NewDefaultEndpointResolverV2()
  1561  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1562  	_, _ = result, err
  1563  
  1564  	if err != nil {
  1565  		t.Fatalf("expect no error, got %v", err)
  1566  	}
  1567  
  1568  	uri, _ := url.Parse("https://sts.us-iso-west-1.c2s.ic.gov")
  1569  
  1570  	expectEndpoint := smithyendpoints.Endpoint{
  1571  		URI:        *uri,
  1572  		Headers:    http.Header{},
  1573  		Properties: smithy.Properties{},
  1574  	}
  1575  
  1576  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1577  		t.Errorf("expect %v URI, got %v", e, a)
  1578  	}
  1579  
  1580  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1581  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1582  	}
  1583  
  1584  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1585  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1586  	}
  1587  }
  1588  
  1589  // For region us-iso-east-1 with FIPS enabled and DualStack enabled
  1590  func TestEndpointCase42(t *testing.T) {
  1591  	var params = EndpointParameters{
  1592  		Region:       ptr.String("us-iso-east-1"),
  1593  		UseFIPS:      ptr.Bool(true),
  1594  		UseDualStack: ptr.Bool(true),
  1595  	}
  1596  
  1597  	resolver := NewDefaultEndpointResolverV2()
  1598  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1599  	_, _ = result, err
  1600  
  1601  	if err == nil {
  1602  		t.Fatalf("expect error, got none")
  1603  	}
  1604  	if e, a := "FIPS and DualStack are enabled, but this partition does not support one or both", err.Error(); !strings.Contains(a, e) {
  1605  		t.Errorf("expect %v error in %v", e, a)
  1606  	}
  1607  }
  1608  
  1609  // For region us-iso-east-1 with FIPS enabled and DualStack disabled
  1610  func TestEndpointCase43(t *testing.T) {
  1611  	var params = EndpointParameters{
  1612  		Region:       ptr.String("us-iso-east-1"),
  1613  		UseFIPS:      ptr.Bool(true),
  1614  		UseDualStack: ptr.Bool(false),
  1615  	}
  1616  
  1617  	resolver := NewDefaultEndpointResolverV2()
  1618  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1619  	_, _ = result, err
  1620  
  1621  	if err != nil {
  1622  		t.Fatalf("expect no error, got %v", err)
  1623  	}
  1624  
  1625  	uri, _ := url.Parse("https://sts-fips.us-iso-east-1.c2s.ic.gov")
  1626  
  1627  	expectEndpoint := smithyendpoints.Endpoint{
  1628  		URI:        *uri,
  1629  		Headers:    http.Header{},
  1630  		Properties: smithy.Properties{},
  1631  	}
  1632  
  1633  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1634  		t.Errorf("expect %v URI, got %v", e, a)
  1635  	}
  1636  
  1637  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1638  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1639  	}
  1640  
  1641  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1642  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1643  	}
  1644  }
  1645  
  1646  // For region us-iso-east-1 with FIPS disabled and DualStack enabled
  1647  func TestEndpointCase44(t *testing.T) {
  1648  	var params = EndpointParameters{
  1649  		Region:       ptr.String("us-iso-east-1"),
  1650  		UseFIPS:      ptr.Bool(false),
  1651  		UseDualStack: ptr.Bool(true),
  1652  	}
  1653  
  1654  	resolver := NewDefaultEndpointResolverV2()
  1655  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1656  	_, _ = result, err
  1657  
  1658  	if err == nil {
  1659  		t.Fatalf("expect error, got none")
  1660  	}
  1661  	if e, a := "DualStack is enabled but this partition does not support DualStack", err.Error(); !strings.Contains(a, e) {
  1662  		t.Errorf("expect %v error in %v", e, a)
  1663  	}
  1664  }
  1665  
  1666  // For region us-isob-east-1 with FIPS disabled and DualStack disabled
  1667  func TestEndpointCase45(t *testing.T) {
  1668  	var params = EndpointParameters{
  1669  		Region:       ptr.String("us-isob-east-1"),
  1670  		UseFIPS:      ptr.Bool(false),
  1671  		UseDualStack: ptr.Bool(false),
  1672  	}
  1673  
  1674  	resolver := NewDefaultEndpointResolverV2()
  1675  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1676  	_, _ = result, err
  1677  
  1678  	if err != nil {
  1679  		t.Fatalf("expect no error, got %v", err)
  1680  	}
  1681  
  1682  	uri, _ := url.Parse("https://sts.us-isob-east-1.sc2s.sgov.gov")
  1683  
  1684  	expectEndpoint := smithyendpoints.Endpoint{
  1685  		URI:        *uri,
  1686  		Headers:    http.Header{},
  1687  		Properties: smithy.Properties{},
  1688  	}
  1689  
  1690  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1691  		t.Errorf("expect %v URI, got %v", e, a)
  1692  	}
  1693  
  1694  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1695  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1696  	}
  1697  
  1698  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1699  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1700  	}
  1701  }
  1702  
  1703  // For region us-isob-east-1 with FIPS enabled and DualStack enabled
  1704  func TestEndpointCase46(t *testing.T) {
  1705  	var params = EndpointParameters{
  1706  		Region:       ptr.String("us-isob-east-1"),
  1707  		UseFIPS:      ptr.Bool(true),
  1708  		UseDualStack: ptr.Bool(true),
  1709  	}
  1710  
  1711  	resolver := NewDefaultEndpointResolverV2()
  1712  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1713  	_, _ = result, err
  1714  
  1715  	if err == nil {
  1716  		t.Fatalf("expect error, got none")
  1717  	}
  1718  	if e, a := "FIPS and DualStack are enabled, but this partition does not support one or both", err.Error(); !strings.Contains(a, e) {
  1719  		t.Errorf("expect %v error in %v", e, a)
  1720  	}
  1721  }
  1722  
  1723  // For region us-isob-east-1 with FIPS enabled and DualStack disabled
  1724  func TestEndpointCase47(t *testing.T) {
  1725  	var params = EndpointParameters{
  1726  		Region:       ptr.String("us-isob-east-1"),
  1727  		UseFIPS:      ptr.Bool(true),
  1728  		UseDualStack: ptr.Bool(false),
  1729  	}
  1730  
  1731  	resolver := NewDefaultEndpointResolverV2()
  1732  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1733  	_, _ = result, err
  1734  
  1735  	if err != nil {
  1736  		t.Fatalf("expect no error, got %v", err)
  1737  	}
  1738  
  1739  	uri, _ := url.Parse("https://sts-fips.us-isob-east-1.sc2s.sgov.gov")
  1740  
  1741  	expectEndpoint := smithyendpoints.Endpoint{
  1742  		URI:        *uri,
  1743  		Headers:    http.Header{},
  1744  		Properties: smithy.Properties{},
  1745  	}
  1746  
  1747  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1748  		t.Errorf("expect %v URI, got %v", e, a)
  1749  	}
  1750  
  1751  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1752  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1753  	}
  1754  
  1755  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1756  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1757  	}
  1758  }
  1759  
  1760  // For region us-isob-east-1 with FIPS disabled and DualStack enabled
  1761  func TestEndpointCase48(t *testing.T) {
  1762  	var params = EndpointParameters{
  1763  		Region:       ptr.String("us-isob-east-1"),
  1764  		UseFIPS:      ptr.Bool(false),
  1765  		UseDualStack: ptr.Bool(true),
  1766  	}
  1767  
  1768  	resolver := NewDefaultEndpointResolverV2()
  1769  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1770  	_, _ = result, err
  1771  
  1772  	if err == nil {
  1773  		t.Fatalf("expect error, got none")
  1774  	}
  1775  	if e, a := "DualStack is enabled but this partition does not support DualStack", err.Error(); !strings.Contains(a, e) {
  1776  		t.Errorf("expect %v error in %v", e, a)
  1777  	}
  1778  }
  1779  
  1780  // For custom endpoint with region set and fips disabled and dualstack disabled
  1781  func TestEndpointCase49(t *testing.T) {
  1782  	var params = EndpointParameters{
  1783  		Region:       ptr.String("us-east-1"),
  1784  		UseFIPS:      ptr.Bool(false),
  1785  		UseDualStack: ptr.Bool(false),
  1786  		Endpoint:     ptr.String("https://example.com"),
  1787  	}
  1788  
  1789  	resolver := NewDefaultEndpointResolverV2()
  1790  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1791  	_, _ = result, err
  1792  
  1793  	if err != nil {
  1794  		t.Fatalf("expect no error, got %v", err)
  1795  	}
  1796  
  1797  	uri, _ := url.Parse("https://example.com")
  1798  
  1799  	expectEndpoint := smithyendpoints.Endpoint{
  1800  		URI:        *uri,
  1801  		Headers:    http.Header{},
  1802  		Properties: smithy.Properties{},
  1803  	}
  1804  
  1805  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1806  		t.Errorf("expect %v URI, got %v", e, a)
  1807  	}
  1808  
  1809  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1810  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1811  	}
  1812  
  1813  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1814  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1815  	}
  1816  }
  1817  
  1818  // For custom endpoint with region not set and fips disabled and dualstack disabled
  1819  func TestEndpointCase50(t *testing.T) {
  1820  	var params = EndpointParameters{
  1821  		UseFIPS:      ptr.Bool(false),
  1822  		UseDualStack: ptr.Bool(false),
  1823  		Endpoint:     ptr.String("https://example.com"),
  1824  	}
  1825  
  1826  	resolver := NewDefaultEndpointResolverV2()
  1827  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1828  	_, _ = result, err
  1829  
  1830  	if err != nil {
  1831  		t.Fatalf("expect no error, got %v", err)
  1832  	}
  1833  
  1834  	uri, _ := url.Parse("https://example.com")
  1835  
  1836  	expectEndpoint := smithyendpoints.Endpoint{
  1837  		URI:        *uri,
  1838  		Headers:    http.Header{},
  1839  		Properties: smithy.Properties{},
  1840  	}
  1841  
  1842  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1843  		t.Errorf("expect %v URI, got %v", e, a)
  1844  	}
  1845  
  1846  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1847  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1848  	}
  1849  
  1850  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1851  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1852  	}
  1853  }
  1854  
  1855  // For custom endpoint with fips enabled and dualstack disabled
  1856  func TestEndpointCase51(t *testing.T) {
  1857  	var params = EndpointParameters{
  1858  		Region:       ptr.String("us-east-1"),
  1859  		UseFIPS:      ptr.Bool(true),
  1860  		UseDualStack: ptr.Bool(false),
  1861  		Endpoint:     ptr.String("https://example.com"),
  1862  	}
  1863  
  1864  	resolver := NewDefaultEndpointResolverV2()
  1865  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1866  	_, _ = result, err
  1867  
  1868  	if err == nil {
  1869  		t.Fatalf("expect error, got none")
  1870  	}
  1871  	if e, a := "Invalid Configuration: FIPS and custom endpoint are not supported", err.Error(); !strings.Contains(a, e) {
  1872  		t.Errorf("expect %v error in %v", e, a)
  1873  	}
  1874  }
  1875  
  1876  // For custom endpoint with fips disabled and dualstack enabled
  1877  func TestEndpointCase52(t *testing.T) {
  1878  	var params = EndpointParameters{
  1879  		Region:       ptr.String("us-east-1"),
  1880  		UseFIPS:      ptr.Bool(false),
  1881  		UseDualStack: ptr.Bool(true),
  1882  		Endpoint:     ptr.String("https://example.com"),
  1883  	}
  1884  
  1885  	resolver := NewDefaultEndpointResolverV2()
  1886  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1887  	_, _ = result, err
  1888  
  1889  	if err == nil {
  1890  		t.Fatalf("expect error, got none")
  1891  	}
  1892  	if e, a := "Invalid Configuration: Dualstack and custom endpoint are not supported", err.Error(); !strings.Contains(a, e) {
  1893  		t.Errorf("expect %v error in %v", e, a)
  1894  	}
  1895  }
  1896  
  1897  // Missing region
  1898  func TestEndpointCase53(t *testing.T) {
  1899  	var params = EndpointParameters{}
  1900  
  1901  	resolver := NewDefaultEndpointResolverV2()
  1902  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1903  	_, _ = result, err
  1904  
  1905  	if err == nil {
  1906  		t.Fatalf("expect error, got none")
  1907  	}
  1908  	if e, a := "Invalid Configuration: Missing Region", err.Error(); !strings.Contains(a, e) {
  1909  		t.Errorf("expect %v error in %v", e, a)
  1910  	}
  1911  }
  1912  
  1913  // UseGlobalEndpoint with legacy region `ap-northeast-1`
  1914  func TestEndpointCase54(t *testing.T) {
  1915  	var params = EndpointParameters{
  1916  		Region:            ptr.String("ap-northeast-1"),
  1917  		UseFIPS:           ptr.Bool(false),
  1918  		UseDualStack:      ptr.Bool(false),
  1919  		UseGlobalEndpoint: ptr.Bool(true),
  1920  	}
  1921  
  1922  	resolver := NewDefaultEndpointResolverV2()
  1923  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1924  	_, _ = result, err
  1925  
  1926  	if err != nil {
  1927  		t.Fatalf("expect no error, got %v", err)
  1928  	}
  1929  
  1930  	uri, _ := url.Parse("https://sts.amazonaws.com")
  1931  
  1932  	expectEndpoint := smithyendpoints.Endpoint{
  1933  		URI:     *uri,
  1934  		Headers: http.Header{},
  1935  		Properties: func() smithy.Properties {
  1936  			var out smithy.Properties
  1937  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  1938  				{
  1939  					SchemeID: "aws.auth#sigv4",
  1940  					SignerProperties: func() smithy.Properties {
  1941  						var sp smithy.Properties
  1942  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  1943  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  1944  
  1945  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  1946  						return sp
  1947  					}(),
  1948  				},
  1949  			})
  1950  			return out
  1951  		}(),
  1952  	}
  1953  
  1954  	if e, a := expectEndpoint.URI, result.URI; e != a {
  1955  		t.Errorf("expect %v URI, got %v", e, a)
  1956  	}
  1957  
  1958  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  1959  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  1960  	}
  1961  
  1962  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  1963  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  1964  	}
  1965  }
  1966  
  1967  // UseGlobalEndpoint with legacy region `ap-south-1`
  1968  func TestEndpointCase55(t *testing.T) {
  1969  	var params = EndpointParameters{
  1970  		Region:            ptr.String("ap-south-1"),
  1971  		UseFIPS:           ptr.Bool(false),
  1972  		UseDualStack:      ptr.Bool(false),
  1973  		UseGlobalEndpoint: ptr.Bool(true),
  1974  	}
  1975  
  1976  	resolver := NewDefaultEndpointResolverV2()
  1977  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  1978  	_, _ = result, err
  1979  
  1980  	if err != nil {
  1981  		t.Fatalf("expect no error, got %v", err)
  1982  	}
  1983  
  1984  	uri, _ := url.Parse("https://sts.amazonaws.com")
  1985  
  1986  	expectEndpoint := smithyendpoints.Endpoint{
  1987  		URI:     *uri,
  1988  		Headers: http.Header{},
  1989  		Properties: func() smithy.Properties {
  1990  			var out smithy.Properties
  1991  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  1992  				{
  1993  					SchemeID: "aws.auth#sigv4",
  1994  					SignerProperties: func() smithy.Properties {
  1995  						var sp smithy.Properties
  1996  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  1997  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  1998  
  1999  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2000  						return sp
  2001  					}(),
  2002  				},
  2003  			})
  2004  			return out
  2005  		}(),
  2006  	}
  2007  
  2008  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2009  		t.Errorf("expect %v URI, got %v", e, a)
  2010  	}
  2011  
  2012  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2013  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2014  	}
  2015  
  2016  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2017  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2018  	}
  2019  }
  2020  
  2021  // UseGlobalEndpoint with legacy region `ap-southeast-1`
  2022  func TestEndpointCase56(t *testing.T) {
  2023  	var params = EndpointParameters{
  2024  		Region:            ptr.String("ap-southeast-1"),
  2025  		UseFIPS:           ptr.Bool(false),
  2026  		UseDualStack:      ptr.Bool(false),
  2027  		UseGlobalEndpoint: ptr.Bool(true),
  2028  	}
  2029  
  2030  	resolver := NewDefaultEndpointResolverV2()
  2031  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2032  	_, _ = result, err
  2033  
  2034  	if err != nil {
  2035  		t.Fatalf("expect no error, got %v", err)
  2036  	}
  2037  
  2038  	uri, _ := url.Parse("https://sts.amazonaws.com")
  2039  
  2040  	expectEndpoint := smithyendpoints.Endpoint{
  2041  		URI:     *uri,
  2042  		Headers: http.Header{},
  2043  		Properties: func() smithy.Properties {
  2044  			var out smithy.Properties
  2045  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2046  				{
  2047  					SchemeID: "aws.auth#sigv4",
  2048  					SignerProperties: func() smithy.Properties {
  2049  						var sp smithy.Properties
  2050  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2051  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2052  
  2053  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2054  						return sp
  2055  					}(),
  2056  				},
  2057  			})
  2058  			return out
  2059  		}(),
  2060  	}
  2061  
  2062  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2063  		t.Errorf("expect %v URI, got %v", e, a)
  2064  	}
  2065  
  2066  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2067  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2068  	}
  2069  
  2070  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2071  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2072  	}
  2073  }
  2074  
  2075  // UseGlobalEndpoint with legacy region `ap-southeast-2`
  2076  func TestEndpointCase57(t *testing.T) {
  2077  	var params = EndpointParameters{
  2078  		Region:            ptr.String("ap-southeast-2"),
  2079  		UseFIPS:           ptr.Bool(false),
  2080  		UseDualStack:      ptr.Bool(false),
  2081  		UseGlobalEndpoint: ptr.Bool(true),
  2082  	}
  2083  
  2084  	resolver := NewDefaultEndpointResolverV2()
  2085  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2086  	_, _ = result, err
  2087  
  2088  	if err != nil {
  2089  		t.Fatalf("expect no error, got %v", err)
  2090  	}
  2091  
  2092  	uri, _ := url.Parse("https://sts.amazonaws.com")
  2093  
  2094  	expectEndpoint := smithyendpoints.Endpoint{
  2095  		URI:     *uri,
  2096  		Headers: http.Header{},
  2097  		Properties: func() smithy.Properties {
  2098  			var out smithy.Properties
  2099  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2100  				{
  2101  					SchemeID: "aws.auth#sigv4",
  2102  					SignerProperties: func() smithy.Properties {
  2103  						var sp smithy.Properties
  2104  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2105  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2106  
  2107  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2108  						return sp
  2109  					}(),
  2110  				},
  2111  			})
  2112  			return out
  2113  		}(),
  2114  	}
  2115  
  2116  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2117  		t.Errorf("expect %v URI, got %v", e, a)
  2118  	}
  2119  
  2120  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2121  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2122  	}
  2123  
  2124  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2125  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2126  	}
  2127  }
  2128  
  2129  // UseGlobalEndpoint with legacy region `aws-global`
  2130  func TestEndpointCase58(t *testing.T) {
  2131  	var params = EndpointParameters{
  2132  		Region:            ptr.String("aws-global"),
  2133  		UseFIPS:           ptr.Bool(false),
  2134  		UseDualStack:      ptr.Bool(false),
  2135  		UseGlobalEndpoint: ptr.Bool(true),
  2136  	}
  2137  
  2138  	resolver := NewDefaultEndpointResolverV2()
  2139  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2140  	_, _ = result, err
  2141  
  2142  	if err != nil {
  2143  		t.Fatalf("expect no error, got %v", err)
  2144  	}
  2145  
  2146  	uri, _ := url.Parse("https://sts.amazonaws.com")
  2147  
  2148  	expectEndpoint := smithyendpoints.Endpoint{
  2149  		URI:     *uri,
  2150  		Headers: http.Header{},
  2151  		Properties: func() smithy.Properties {
  2152  			var out smithy.Properties
  2153  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2154  				{
  2155  					SchemeID: "aws.auth#sigv4",
  2156  					SignerProperties: func() smithy.Properties {
  2157  						var sp smithy.Properties
  2158  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2159  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2160  
  2161  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2162  						return sp
  2163  					}(),
  2164  				},
  2165  			})
  2166  			return out
  2167  		}(),
  2168  	}
  2169  
  2170  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2171  		t.Errorf("expect %v URI, got %v", e, a)
  2172  	}
  2173  
  2174  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2175  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2176  	}
  2177  
  2178  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2179  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2180  	}
  2181  }
  2182  
  2183  // UseGlobalEndpoint with legacy region `ca-central-1`
  2184  func TestEndpointCase59(t *testing.T) {
  2185  	var params = EndpointParameters{
  2186  		Region:            ptr.String("ca-central-1"),
  2187  		UseFIPS:           ptr.Bool(false),
  2188  		UseDualStack:      ptr.Bool(false),
  2189  		UseGlobalEndpoint: ptr.Bool(true),
  2190  	}
  2191  
  2192  	resolver := NewDefaultEndpointResolverV2()
  2193  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2194  	_, _ = result, err
  2195  
  2196  	if err != nil {
  2197  		t.Fatalf("expect no error, got %v", err)
  2198  	}
  2199  
  2200  	uri, _ := url.Parse("https://sts.amazonaws.com")
  2201  
  2202  	expectEndpoint := smithyendpoints.Endpoint{
  2203  		URI:     *uri,
  2204  		Headers: http.Header{},
  2205  		Properties: func() smithy.Properties {
  2206  			var out smithy.Properties
  2207  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2208  				{
  2209  					SchemeID: "aws.auth#sigv4",
  2210  					SignerProperties: func() smithy.Properties {
  2211  						var sp smithy.Properties
  2212  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2213  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2214  
  2215  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2216  						return sp
  2217  					}(),
  2218  				},
  2219  			})
  2220  			return out
  2221  		}(),
  2222  	}
  2223  
  2224  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2225  		t.Errorf("expect %v URI, got %v", e, a)
  2226  	}
  2227  
  2228  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2229  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2230  	}
  2231  
  2232  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2233  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2234  	}
  2235  }
  2236  
  2237  // UseGlobalEndpoint with legacy region `eu-central-1`
  2238  func TestEndpointCase60(t *testing.T) {
  2239  	var params = EndpointParameters{
  2240  		Region:            ptr.String("eu-central-1"),
  2241  		UseFIPS:           ptr.Bool(false),
  2242  		UseDualStack:      ptr.Bool(false),
  2243  		UseGlobalEndpoint: ptr.Bool(true),
  2244  	}
  2245  
  2246  	resolver := NewDefaultEndpointResolverV2()
  2247  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2248  	_, _ = result, err
  2249  
  2250  	if err != nil {
  2251  		t.Fatalf("expect no error, got %v", err)
  2252  	}
  2253  
  2254  	uri, _ := url.Parse("https://sts.amazonaws.com")
  2255  
  2256  	expectEndpoint := smithyendpoints.Endpoint{
  2257  		URI:     *uri,
  2258  		Headers: http.Header{},
  2259  		Properties: func() smithy.Properties {
  2260  			var out smithy.Properties
  2261  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2262  				{
  2263  					SchemeID: "aws.auth#sigv4",
  2264  					SignerProperties: func() smithy.Properties {
  2265  						var sp smithy.Properties
  2266  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2267  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2268  
  2269  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2270  						return sp
  2271  					}(),
  2272  				},
  2273  			})
  2274  			return out
  2275  		}(),
  2276  	}
  2277  
  2278  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2279  		t.Errorf("expect %v URI, got %v", e, a)
  2280  	}
  2281  
  2282  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2283  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2284  	}
  2285  
  2286  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2287  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2288  	}
  2289  }
  2290  
  2291  // UseGlobalEndpoint with legacy region `eu-north-1`
  2292  func TestEndpointCase61(t *testing.T) {
  2293  	var params = EndpointParameters{
  2294  		Region:            ptr.String("eu-north-1"),
  2295  		UseFIPS:           ptr.Bool(false),
  2296  		UseDualStack:      ptr.Bool(false),
  2297  		UseGlobalEndpoint: ptr.Bool(true),
  2298  	}
  2299  
  2300  	resolver := NewDefaultEndpointResolverV2()
  2301  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2302  	_, _ = result, err
  2303  
  2304  	if err != nil {
  2305  		t.Fatalf("expect no error, got %v", err)
  2306  	}
  2307  
  2308  	uri, _ := url.Parse("https://sts.amazonaws.com")
  2309  
  2310  	expectEndpoint := smithyendpoints.Endpoint{
  2311  		URI:     *uri,
  2312  		Headers: http.Header{},
  2313  		Properties: func() smithy.Properties {
  2314  			var out smithy.Properties
  2315  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2316  				{
  2317  					SchemeID: "aws.auth#sigv4",
  2318  					SignerProperties: func() smithy.Properties {
  2319  						var sp smithy.Properties
  2320  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2321  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2322  
  2323  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2324  						return sp
  2325  					}(),
  2326  				},
  2327  			})
  2328  			return out
  2329  		}(),
  2330  	}
  2331  
  2332  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2333  		t.Errorf("expect %v URI, got %v", e, a)
  2334  	}
  2335  
  2336  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2337  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2338  	}
  2339  
  2340  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2341  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2342  	}
  2343  }
  2344  
  2345  // UseGlobalEndpoint with legacy region `eu-west-1`
  2346  func TestEndpointCase62(t *testing.T) {
  2347  	var params = EndpointParameters{
  2348  		Region:            ptr.String("eu-west-1"),
  2349  		UseFIPS:           ptr.Bool(false),
  2350  		UseDualStack:      ptr.Bool(false),
  2351  		UseGlobalEndpoint: ptr.Bool(true),
  2352  	}
  2353  
  2354  	resolver := NewDefaultEndpointResolverV2()
  2355  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2356  	_, _ = result, err
  2357  
  2358  	if err != nil {
  2359  		t.Fatalf("expect no error, got %v", err)
  2360  	}
  2361  
  2362  	uri, _ := url.Parse("https://sts.amazonaws.com")
  2363  
  2364  	expectEndpoint := smithyendpoints.Endpoint{
  2365  		URI:     *uri,
  2366  		Headers: http.Header{},
  2367  		Properties: func() smithy.Properties {
  2368  			var out smithy.Properties
  2369  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2370  				{
  2371  					SchemeID: "aws.auth#sigv4",
  2372  					SignerProperties: func() smithy.Properties {
  2373  						var sp smithy.Properties
  2374  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2375  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2376  
  2377  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2378  						return sp
  2379  					}(),
  2380  				},
  2381  			})
  2382  			return out
  2383  		}(),
  2384  	}
  2385  
  2386  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2387  		t.Errorf("expect %v URI, got %v", e, a)
  2388  	}
  2389  
  2390  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2391  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2392  	}
  2393  
  2394  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2395  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2396  	}
  2397  }
  2398  
  2399  // UseGlobalEndpoint with legacy region `eu-west-2`
  2400  func TestEndpointCase63(t *testing.T) {
  2401  	var params = EndpointParameters{
  2402  		Region:            ptr.String("eu-west-2"),
  2403  		UseFIPS:           ptr.Bool(false),
  2404  		UseDualStack:      ptr.Bool(false),
  2405  		UseGlobalEndpoint: ptr.Bool(true),
  2406  	}
  2407  
  2408  	resolver := NewDefaultEndpointResolverV2()
  2409  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2410  	_, _ = result, err
  2411  
  2412  	if err != nil {
  2413  		t.Fatalf("expect no error, got %v", err)
  2414  	}
  2415  
  2416  	uri, _ := url.Parse("https://sts.amazonaws.com")
  2417  
  2418  	expectEndpoint := smithyendpoints.Endpoint{
  2419  		URI:     *uri,
  2420  		Headers: http.Header{},
  2421  		Properties: func() smithy.Properties {
  2422  			var out smithy.Properties
  2423  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2424  				{
  2425  					SchemeID: "aws.auth#sigv4",
  2426  					SignerProperties: func() smithy.Properties {
  2427  						var sp smithy.Properties
  2428  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2429  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2430  
  2431  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2432  						return sp
  2433  					}(),
  2434  				},
  2435  			})
  2436  			return out
  2437  		}(),
  2438  	}
  2439  
  2440  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2441  		t.Errorf("expect %v URI, got %v", e, a)
  2442  	}
  2443  
  2444  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2445  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2446  	}
  2447  
  2448  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2449  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2450  	}
  2451  }
  2452  
  2453  // UseGlobalEndpoint with legacy region `eu-west-3`
  2454  func TestEndpointCase64(t *testing.T) {
  2455  	var params = EndpointParameters{
  2456  		Region:            ptr.String("eu-west-3"),
  2457  		UseFIPS:           ptr.Bool(false),
  2458  		UseDualStack:      ptr.Bool(false),
  2459  		UseGlobalEndpoint: ptr.Bool(true),
  2460  	}
  2461  
  2462  	resolver := NewDefaultEndpointResolverV2()
  2463  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2464  	_, _ = result, err
  2465  
  2466  	if err != nil {
  2467  		t.Fatalf("expect no error, got %v", err)
  2468  	}
  2469  
  2470  	uri, _ := url.Parse("https://sts.amazonaws.com")
  2471  
  2472  	expectEndpoint := smithyendpoints.Endpoint{
  2473  		URI:     *uri,
  2474  		Headers: http.Header{},
  2475  		Properties: func() smithy.Properties {
  2476  			var out smithy.Properties
  2477  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2478  				{
  2479  					SchemeID: "aws.auth#sigv4",
  2480  					SignerProperties: func() smithy.Properties {
  2481  						var sp smithy.Properties
  2482  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2483  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2484  
  2485  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2486  						return sp
  2487  					}(),
  2488  				},
  2489  			})
  2490  			return out
  2491  		}(),
  2492  	}
  2493  
  2494  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2495  		t.Errorf("expect %v URI, got %v", e, a)
  2496  	}
  2497  
  2498  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2499  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2500  	}
  2501  
  2502  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2503  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2504  	}
  2505  }
  2506  
  2507  // UseGlobalEndpoint with legacy region `sa-east-1`
  2508  func TestEndpointCase65(t *testing.T) {
  2509  	var params = EndpointParameters{
  2510  		Region:            ptr.String("sa-east-1"),
  2511  		UseFIPS:           ptr.Bool(false),
  2512  		UseDualStack:      ptr.Bool(false),
  2513  		UseGlobalEndpoint: ptr.Bool(true),
  2514  	}
  2515  
  2516  	resolver := NewDefaultEndpointResolverV2()
  2517  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2518  	_, _ = result, err
  2519  
  2520  	if err != nil {
  2521  		t.Fatalf("expect no error, got %v", err)
  2522  	}
  2523  
  2524  	uri, _ := url.Parse("https://sts.amazonaws.com")
  2525  
  2526  	expectEndpoint := smithyendpoints.Endpoint{
  2527  		URI:     *uri,
  2528  		Headers: http.Header{},
  2529  		Properties: func() smithy.Properties {
  2530  			var out smithy.Properties
  2531  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2532  				{
  2533  					SchemeID: "aws.auth#sigv4",
  2534  					SignerProperties: func() smithy.Properties {
  2535  						var sp smithy.Properties
  2536  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2537  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2538  
  2539  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2540  						return sp
  2541  					}(),
  2542  				},
  2543  			})
  2544  			return out
  2545  		}(),
  2546  	}
  2547  
  2548  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2549  		t.Errorf("expect %v URI, got %v", e, a)
  2550  	}
  2551  
  2552  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2553  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2554  	}
  2555  
  2556  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2557  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2558  	}
  2559  }
  2560  
  2561  // UseGlobalEndpoint with legacy region `us-east-1`
  2562  func TestEndpointCase66(t *testing.T) {
  2563  	var params = EndpointParameters{
  2564  		Region:            ptr.String("us-east-1"),
  2565  		UseFIPS:           ptr.Bool(false),
  2566  		UseDualStack:      ptr.Bool(false),
  2567  		UseGlobalEndpoint: ptr.Bool(true),
  2568  	}
  2569  
  2570  	resolver := NewDefaultEndpointResolverV2()
  2571  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2572  	_, _ = result, err
  2573  
  2574  	if err != nil {
  2575  		t.Fatalf("expect no error, got %v", err)
  2576  	}
  2577  
  2578  	uri, _ := url.Parse("https://sts.amazonaws.com")
  2579  
  2580  	expectEndpoint := smithyendpoints.Endpoint{
  2581  		URI:     *uri,
  2582  		Headers: http.Header{},
  2583  		Properties: func() smithy.Properties {
  2584  			var out smithy.Properties
  2585  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2586  				{
  2587  					SchemeID: "aws.auth#sigv4",
  2588  					SignerProperties: func() smithy.Properties {
  2589  						var sp smithy.Properties
  2590  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2591  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2592  
  2593  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2594  						return sp
  2595  					}(),
  2596  				},
  2597  			})
  2598  			return out
  2599  		}(),
  2600  	}
  2601  
  2602  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2603  		t.Errorf("expect %v URI, got %v", e, a)
  2604  	}
  2605  
  2606  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2607  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2608  	}
  2609  
  2610  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2611  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2612  	}
  2613  }
  2614  
  2615  // UseGlobalEndpoint with legacy region `us-east-2`
  2616  func TestEndpointCase67(t *testing.T) {
  2617  	var params = EndpointParameters{
  2618  		Region:            ptr.String("us-east-2"),
  2619  		UseFIPS:           ptr.Bool(false),
  2620  		UseDualStack:      ptr.Bool(false),
  2621  		UseGlobalEndpoint: ptr.Bool(true),
  2622  	}
  2623  
  2624  	resolver := NewDefaultEndpointResolverV2()
  2625  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2626  	_, _ = result, err
  2627  
  2628  	if err != nil {
  2629  		t.Fatalf("expect no error, got %v", err)
  2630  	}
  2631  
  2632  	uri, _ := url.Parse("https://sts.amazonaws.com")
  2633  
  2634  	expectEndpoint := smithyendpoints.Endpoint{
  2635  		URI:     *uri,
  2636  		Headers: http.Header{},
  2637  		Properties: func() smithy.Properties {
  2638  			var out smithy.Properties
  2639  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2640  				{
  2641  					SchemeID: "aws.auth#sigv4",
  2642  					SignerProperties: func() smithy.Properties {
  2643  						var sp smithy.Properties
  2644  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2645  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2646  
  2647  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2648  						return sp
  2649  					}(),
  2650  				},
  2651  			})
  2652  			return out
  2653  		}(),
  2654  	}
  2655  
  2656  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2657  		t.Errorf("expect %v URI, got %v", e, a)
  2658  	}
  2659  
  2660  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2661  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2662  	}
  2663  
  2664  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2665  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2666  	}
  2667  }
  2668  
  2669  // UseGlobalEndpoint with legacy region `us-west-1`
  2670  func TestEndpointCase68(t *testing.T) {
  2671  	var params = EndpointParameters{
  2672  		Region:            ptr.String("us-west-1"),
  2673  		UseFIPS:           ptr.Bool(false),
  2674  		UseDualStack:      ptr.Bool(false),
  2675  		UseGlobalEndpoint: ptr.Bool(true),
  2676  	}
  2677  
  2678  	resolver := NewDefaultEndpointResolverV2()
  2679  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2680  	_, _ = result, err
  2681  
  2682  	if err != nil {
  2683  		t.Fatalf("expect no error, got %v", err)
  2684  	}
  2685  
  2686  	uri, _ := url.Parse("https://sts.amazonaws.com")
  2687  
  2688  	expectEndpoint := smithyendpoints.Endpoint{
  2689  		URI:     *uri,
  2690  		Headers: http.Header{},
  2691  		Properties: func() smithy.Properties {
  2692  			var out smithy.Properties
  2693  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2694  				{
  2695  					SchemeID: "aws.auth#sigv4",
  2696  					SignerProperties: func() smithy.Properties {
  2697  						var sp smithy.Properties
  2698  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2699  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2700  
  2701  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2702  						return sp
  2703  					}(),
  2704  				},
  2705  			})
  2706  			return out
  2707  		}(),
  2708  	}
  2709  
  2710  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2711  		t.Errorf("expect %v URI, got %v", e, a)
  2712  	}
  2713  
  2714  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2715  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2716  	}
  2717  
  2718  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2719  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2720  	}
  2721  }
  2722  
  2723  // UseGlobalEndpoint with legacy region `us-west-2`
  2724  func TestEndpointCase69(t *testing.T) {
  2725  	var params = EndpointParameters{
  2726  		Region:            ptr.String("us-west-2"),
  2727  		UseFIPS:           ptr.Bool(false),
  2728  		UseDualStack:      ptr.Bool(false),
  2729  		UseGlobalEndpoint: ptr.Bool(true),
  2730  	}
  2731  
  2732  	resolver := NewDefaultEndpointResolverV2()
  2733  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2734  	_, _ = result, err
  2735  
  2736  	if err != nil {
  2737  		t.Fatalf("expect no error, got %v", err)
  2738  	}
  2739  
  2740  	uri, _ := url.Parse("https://sts.amazonaws.com")
  2741  
  2742  	expectEndpoint := smithyendpoints.Endpoint{
  2743  		URI:     *uri,
  2744  		Headers: http.Header{},
  2745  		Properties: func() smithy.Properties {
  2746  			var out smithy.Properties
  2747  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2748  				{
  2749  					SchemeID: "aws.auth#sigv4",
  2750  					SignerProperties: func() smithy.Properties {
  2751  						var sp smithy.Properties
  2752  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2753  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2754  
  2755  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-1")
  2756  						return sp
  2757  					}(),
  2758  				},
  2759  			})
  2760  			return out
  2761  		}(),
  2762  	}
  2763  
  2764  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2765  		t.Errorf("expect %v URI, got %v", e, a)
  2766  	}
  2767  
  2768  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2769  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2770  	}
  2771  
  2772  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2773  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2774  	}
  2775  }
  2776  
  2777  // UseGlobalEndpoint with Non-legacy region `us-east-3`
  2778  func TestEndpointCase70(t *testing.T) {
  2779  	var params = EndpointParameters{
  2780  		Region:            ptr.String("us-east-3"),
  2781  		UseFIPS:           ptr.Bool(false),
  2782  		UseDualStack:      ptr.Bool(false),
  2783  		UseGlobalEndpoint: ptr.Bool(true),
  2784  	}
  2785  
  2786  	resolver := NewDefaultEndpointResolverV2()
  2787  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2788  	_, _ = result, err
  2789  
  2790  	if err != nil {
  2791  		t.Fatalf("expect no error, got %v", err)
  2792  	}
  2793  
  2794  	uri, _ := url.Parse("https://sts.us-east-3.amazonaws.com")
  2795  
  2796  	expectEndpoint := smithyendpoints.Endpoint{
  2797  		URI:     *uri,
  2798  		Headers: http.Header{},
  2799  		Properties: func() smithy.Properties {
  2800  			var out smithy.Properties
  2801  			smithyauth.SetAuthOptions(&out, []*smithyauth.Option{
  2802  				{
  2803  					SchemeID: "aws.auth#sigv4",
  2804  					SignerProperties: func() smithy.Properties {
  2805  						var sp smithy.Properties
  2806  						smithyhttp.SetSigV4SigningName(&sp, "sts")
  2807  						smithyhttp.SetSigV4ASigningName(&sp, "sts")
  2808  
  2809  						smithyhttp.SetSigV4SigningRegion(&sp, "us-east-3")
  2810  						return sp
  2811  					}(),
  2812  				},
  2813  			})
  2814  			return out
  2815  		}(),
  2816  	}
  2817  
  2818  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2819  		t.Errorf("expect %v URI, got %v", e, a)
  2820  	}
  2821  
  2822  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2823  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2824  	}
  2825  
  2826  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2827  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2828  	}
  2829  }
  2830  
  2831  // UseGlobalEndpoint with legacy region and custom endpoint
  2832  func TestEndpointCase71(t *testing.T) {
  2833  	var params = EndpointParameters{
  2834  		Region:            ptr.String("us-west-1"),
  2835  		UseFIPS:           ptr.Bool(false),
  2836  		UseDualStack:      ptr.Bool(false),
  2837  		UseGlobalEndpoint: ptr.Bool(true),
  2838  		Endpoint:          ptr.String("https://example.com"),
  2839  	}
  2840  
  2841  	resolver := NewDefaultEndpointResolverV2()
  2842  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2843  	_, _ = result, err
  2844  
  2845  	if err != nil {
  2846  		t.Fatalf("expect no error, got %v", err)
  2847  	}
  2848  
  2849  	uri, _ := url.Parse("https://example.com")
  2850  
  2851  	expectEndpoint := smithyendpoints.Endpoint{
  2852  		URI:        *uri,
  2853  		Headers:    http.Header{},
  2854  		Properties: smithy.Properties{},
  2855  	}
  2856  
  2857  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2858  		t.Errorf("expect %v URI, got %v", e, a)
  2859  	}
  2860  
  2861  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2862  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2863  	}
  2864  
  2865  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2866  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2867  	}
  2868  }
  2869  
  2870  // UseGlobalEndpoint with unset region and custom endpoint
  2871  func TestEndpointCase72(t *testing.T) {
  2872  	var params = EndpointParameters{
  2873  		UseFIPS:           ptr.Bool(false),
  2874  		UseDualStack:      ptr.Bool(false),
  2875  		UseGlobalEndpoint: ptr.Bool(false),
  2876  		Endpoint:          ptr.String("https://example.com"),
  2877  	}
  2878  
  2879  	resolver := NewDefaultEndpointResolverV2()
  2880  	result, err := resolver.ResolveEndpoint(context.Background(), params)
  2881  	_, _ = result, err
  2882  
  2883  	if err != nil {
  2884  		t.Fatalf("expect no error, got %v", err)
  2885  	}
  2886  
  2887  	uri, _ := url.Parse("https://example.com")
  2888  
  2889  	expectEndpoint := smithyendpoints.Endpoint{
  2890  		URI:        *uri,
  2891  		Headers:    http.Header{},
  2892  		Properties: smithy.Properties{},
  2893  	}
  2894  
  2895  	if e, a := expectEndpoint.URI, result.URI; e != a {
  2896  		t.Errorf("expect %v URI, got %v", e, a)
  2897  	}
  2898  
  2899  	if !reflect.DeepEqual(expectEndpoint.Headers, result.Headers) {
  2900  		t.Errorf("expect headers to match\n%v != %v", expectEndpoint.Headers, result.Headers)
  2901  	}
  2902  
  2903  	if !reflect.DeepEqual(expectEndpoint.Properties, result.Properties) {
  2904  		t.Errorf("expect properties to match\n%v != %v", expectEndpoint.Properties, result.Properties)
  2905  	}
  2906  }
  2907  

View as plain text