Fix the dependency issue (#231)

vendor/github.com/aws/aws-sdk-go/private/protocol/ec2query/build_bench_test.go

@@ -1,85 +0,0 @@
-// +build bench
-
-package ec2query_test
-
-import (
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/awstesting"
-	"github.com/aws/aws-sdk-go/private/protocol/ec2query"
-	"github.com/aws/aws-sdk-go/service/ec2"
-)
-
-func BenchmarkEC2QueryBuild_Complex_ec2AuthorizeSecurityGroupEgress(b *testing.B) {
-	params := &ec2.AuthorizeSecurityGroupEgressInput{
-		GroupId:  aws.String("String"), // Required
-		CidrIp:   aws.String("String"),
-		DryRun:   aws.Bool(true),
-		FromPort: aws.Int64(1),
-		IpPermissions: []*ec2.IpPermission{
-			{ // Required
-				FromPort:   aws.Int64(1),
-				IpProtocol: aws.String("String"),
-				IpRanges: []*ec2.IpRange{
-					{ // Required
-						CidrIp: aws.String("String"),
-					},
-					// More values...
-				},
-				PrefixListIds: []*ec2.PrefixListId{
-					{ // Required
-						PrefixListId: aws.String("String"),
-					},
-					// More values...
-				},
-				ToPort: aws.Int64(1),
-				UserIdGroupPairs: []*ec2.UserIdGroupPair{
-					{ // Required
-						GroupId:   aws.String("String"),
-						GroupName: aws.String("String"),
-						UserId:    aws.String("String"),
-					},
-					// More values...
-				},
-			},
-			// More values...
-		},
-		IpProtocol:                 aws.String("String"),
-		SourceSecurityGroupName:    aws.String("String"),
-		SourceSecurityGroupOwnerId: aws.String("String"),
-		ToPort: aws.Int64(1),
-	}
-
-	benchEC2QueryBuild(b, "AuthorizeSecurityGroupEgress", params)
-}
-
-func BenchmarkEC2QueryBuild_Simple_ec2AttachNetworkInterface(b *testing.B) {
-	params := &ec2.AttachNetworkInterfaceInput{
-		DeviceIndex:        aws.Int64(1),         // Required
-		InstanceId:         aws.String("String"), // Required
-		NetworkInterfaceId: aws.String("String"), // Required
-		DryRun:             aws.Bool(true),
-	}
-
-	benchEC2QueryBuild(b, "AttachNetworkInterface", params)
-}
-
-func benchEC2QueryBuild(b *testing.B, opName string, params interface{}) {
-	svc := awstesting.NewClient()
-	svc.ServiceName = "ec2"
-	svc.APIVersion = "2015-04-15"
-
-	for i := 0; i < b.N; i++ {
-		r := svc.NewRequest(&request.Operation{
-			Name:       opName,
-			HTTPMethod: "POST",
-			HTTPPath:   "/",
-		}, params, nil)
-		ec2query.Build(r)
-		if r.Error != nil {
-			b.Fatal("Unexpected error", r.Error)
-		}
-	}
-}

vendor/github.com/aws/aws-sdk-go/private/protocol/idempotency_test.go

@@ -1,106 +0,0 @@
-package protocol_test
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/private/protocol"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestCanSetIdempotencyToken(t *testing.T) {
-	cases := []struct {
-		CanSet bool
-		Case   interface{}
-	}{
-		{
-			true,
-			struct {
-				Field *string `idempotencyToken:"true"`
-			}{},
-		},
-		{
-			true,
-			struct {
-				Field string `idempotencyToken:"true"`
-			}{},
-		},
-		{
-			false,
-			struct {
-				Field *string `idempotencyToken:"true"`
-			}{Field: new(string)},
-		},
-		{
-			false,
-			struct {
-				Field string `idempotencyToken:"true"`
-			}{Field: "value"},
-		},
-		{
-			false,
-			struct {
-				Field *int `idempotencyToken:"true"`
-			}{},
-		},
-		{
-			false,
-			struct {
-				Field *string
-			}{},
-		},
-	}
-
-	for i, c := range cases {
-		v := reflect.Indirect(reflect.ValueOf(c.Case))
-		ty := v.Type()
-		canSet := protocol.CanSetIdempotencyToken(v.Field(0), ty.Field(0))
-		assert.Equal(t, c.CanSet, canSet, "Expect case %d can set to match", i)
-	}
-}
-
-func TestSetIdempotencyToken(t *testing.T) {
-	cases := []struct {
-		Case interface{}
-	}{
-		{
-			&struct {
-				Field *string `idempotencyToken:"true"`
-			}{},
-		},
-		{
-			&struct {
-				Field string `idempotencyToken:"true"`
-			}{},
-		},
-		{
-			&struct {
-				Field *string `idempotencyToken:"true"`
-			}{Field: new(string)},
-		},
-		{
-			&struct {
-				Field string `idempotencyToken:"true"`
-			}{Field: ""},
-		},
-	}
-
-	for i, c := range cases {
-		v := reflect.Indirect(reflect.ValueOf(c.Case))
-
-		protocol.SetIdempotencyToken(v.Field(0))
-		assert.NotEmpty(t, v.Field(0).Interface(), "Expect case %d to be set", i)
-	}
-}
-
-func TestUUIDVersion4(t *testing.T) {
-	uuid := protocol.UUIDVersion4(make([]byte, 16))
-	assert.Equal(t, `00000000-0000-4000-8000-000000000000`, uuid)
-
-	b := make([]byte, 16)
-	for i := 0; i < len(b); i++ {
-		b[i] = 1
-	}
-	uuid = protocol.UUIDVersion4(b)
-	assert.Equal(t, `01010101-0101-4101-8101-010101010101`, uuid)
-}

vendor/github.com/aws/aws-sdk-go/private/protocol/json/jsonutil/build_test.go

@@ -1,109 +0,0 @@
-package jsonutil_test
-
-import (
-	"encoding/json"
-	"testing"
-	"time"
-
-	"github.com/aws/aws-sdk-go/private/protocol/json/jsonutil"
-	"github.com/stretchr/testify/assert"
-)
-
-func S(s string) *string {
-	return &s
-}
-
-func D(s int64) *int64 {
-	return &s
-}
-
-func F(s float64) *float64 {
-	return &s
-}
-
-func T(s time.Time) *time.Time {
-	return &s
-}
-
-type J struct {
-	S  *string
-	SS []string
-	D  *int64
-	F  *float64
-	T  *time.Time
-}
-
-var zero = 0.0
-
-var jsonTests = []struct {
-	in  interface{}
-	out string
-	err string
-}{
-	{
-		J{},
-		`{}`,
-		``,
-	},
-	{
-		J{
-			S:  S("str"),
-			SS: []string{"A", "B", "C"},
-			D:  D(123),
-			F:  F(4.56),
-			T:  T(time.Unix(987, 0)),
-		},
-		`{"S":"str","SS":["A","B","C"],"D":123,"F":4.56,"T":987}`,
-		``,
-	},
-	{
-		J{
-			S: S(`"''"`),
-		},
-		`{"S":"\"''\""}`,
-		``,
-	},
-	{
-		J{
-			S: S("\x00føø\u00FF\n\\\"\r\t\b\f"),
-		},
-		`{"S":"\u0000føøÿ\n\\\"\r\t\b\f"}`,
-		``,
-	},
-	{
-		J{
-			F: F(4.56 / zero),
-		},
-		"",
-		`json: unsupported value: +Inf`,
-	},
-}
-
-func TestBuildJSON(t *testing.T) {
-	for _, test := range jsonTests {
-		out, err := jsonutil.BuildJSON(test.in)
-		if test.err != "" {
-			assert.Error(t, err)
-			assert.Contains(t, err.Error(), test.err)
-		} else {
-			assert.NoError(t, err)
-			assert.Equal(t, string(out), test.out)
-		}
-	}
-}
-
-func BenchmarkBuildJSON(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		for _, test := range jsonTests {
-			jsonutil.BuildJSON(test.in)
-		}
-	}
-}
-
-func BenchmarkStdlibJSON(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		for _, test := range jsonTests {
-			json.Marshal(test.in)
-		}
-	}
-}

vendor/github.com/aws/aws-sdk-go/private/protocol/jsonrpc/build_bench_test.go

@@ -1,71 +0,0 @@
-// +build bench
-
-package jsonrpc_test
-
-import (
-	"bytes"
-	"encoding/json"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/awstesting"
-	"github.com/aws/aws-sdk-go/private/protocol/json/jsonutil"
-	"github.com/aws/aws-sdk-go/private/protocol/jsonrpc"
-	"github.com/aws/aws-sdk-go/service/dynamodb"
-	"github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute"
-)
-
-func BenchmarkJSONRPCBuild_Simple_dynamodbPutItem(b *testing.B) {
-	svc := awstesting.NewClient()
-
-	params := getDynamodbPutItemParams(b)
-
-	for i := 0; i < b.N; i++ {
-		r := svc.NewRequest(&request.Operation{Name: "Operation"}, params, nil)
-		jsonrpc.Build(r)
-		if r.Error != nil {
-			b.Fatal("Unexpected error", r.Error)
-		}
-	}
-}
-
-func BenchmarkJSONUtilBuild_Simple_dynamodbPutItem(b *testing.B) {
-	svc := awstesting.NewClient()
-
-	params := getDynamodbPutItemParams(b)
-
-	for i := 0; i < b.N; i++ {
-		r := svc.NewRequest(&request.Operation{Name: "Operation"}, params, nil)
-		_, err := jsonutil.BuildJSON(r.Params)
-		if err != nil {
-			b.Fatal("Unexpected error", err)
-		}
-	}
-}
-
-func BenchmarkEncodingJSONMarshal_Simple_dynamodbPutItem(b *testing.B) {
-	params := getDynamodbPutItemParams(b)
-
-	for i := 0; i < b.N; i++ {
-		buf := &bytes.Buffer{}
-		encoder := json.NewEncoder(buf)
-		if err := encoder.Encode(params); err != nil {
-			b.Fatal("Unexpected error", err)
-		}
-	}
-}
-
-func getDynamodbPutItemParams(b *testing.B) *dynamodb.PutItemInput {
-	av, err := dynamodbattribute.ConvertToMap(struct {
-		Key  string
-		Data string
-	}{Key: "MyKey", Data: "MyData"})
-	if err != nil {
-		b.Fatal("benchPutItem, expect no ConvertToMap errors", err)
-	}
-	return &dynamodb.PutItemInput{
-		Item:      av,
-		TableName: aws.String("tablename"),
-	}
-}

vendor/github.com/aws/aws-sdk-go/private/protocol/jsonvalue_test.go

@@ -1,93 +0,0 @@
-package protocol
-
-import (
-	"fmt"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-)
-
-var testJSONValueCases = []struct {
-	Value  aws.JSONValue
-	Mode   EscapeMode
-	String string
-}{
-	{
-		Value: aws.JSONValue{
-			"abc": 123.,
-		},
-		Mode:   NoEscape,
-		String: `{"abc":123}`,
-	},
-	{
-		Value: aws.JSONValue{
-			"abc": 123.,
-		},
-		Mode:   Base64Escape,
-		String: `eyJhYmMiOjEyM30=`,
-	},
-	{
-		Value: aws.JSONValue{
-			"abc": 123.,
-		},
-		Mode:   QuotedEscape,
-		String: `"{\"abc\":123}"`,
-	},
-}
-
-func TestEncodeJSONValue(t *testing.T) {
-	for i, c := range testJSONValueCases {
-		str, err := EncodeJSONValue(c.Value, c.Mode)
-		if err != nil {
-			t.Fatalf("%d, expect no error, got %v", i, err)
-		}
-		if e, a := c.String, str; e != a {
-			t.Errorf("%d, expect %v encoded value, got %v", i, e, a)
-		}
-	}
-}
-
-func TestDecodeJSONValue(t *testing.T) {
-	for i, c := range testJSONValueCases {
-		val, err := DecodeJSONValue(c.String, c.Mode)
-		if err != nil {
-			t.Fatalf("%d, expect no error, got %v", i, err)
-		}
-		if e, a := c.Value, val; !reflect.DeepEqual(e, a) {
-			t.Errorf("%d, expect %v encoded value, got %v", i, e, a)
-		}
-	}
-}
-
-func TestEncodeJSONValue_PanicUnkownMode(t *testing.T) {
-	defer func() {
-		if r := recover(); r == nil {
-			t.Errorf("expect panic, got none")
-		} else {
-			reason := fmt.Sprintf("%v", r)
-			if e, a := "unknown EscapeMode", reason; !strings.Contains(a, e) {
-				t.Errorf("expect %q to be in %v", e, a)
-			}
-		}
-	}()
-
-	val := aws.JSONValue{}
-
-	EncodeJSONValue(val, 123456)
-}
-func TestDecodeJSONValue_PanicUnkownMode(t *testing.T) {
-	defer func() {
-		if r := recover(); r == nil {
-			t.Errorf("expect panic, got none")
-		} else {
-			reason := fmt.Sprintf("%v", r)
-			if e, a := "unknown EscapeMode", reason; !strings.Contains(a, e) {
-				t.Errorf("expect %q to be in %v", e, a)
-			}
-		}
-	}()
-
-	DecodeJSONValue(`{"abc":123}`, 123456)
-}

vendor/github.com/aws/aws-sdk-go/private/protocol/protocol_test.go

@@ -1,203 +0,0 @@
-package protocol_test
-
-import (
-	"net/http"
-	"net/url"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/aws/aws-sdk-go/aws/client/metadata"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/awstesting"
-	"github.com/aws/aws-sdk-go/private/protocol"
-	"github.com/aws/aws-sdk-go/private/protocol/ec2query"
-	"github.com/aws/aws-sdk-go/private/protocol/jsonrpc"
-	"github.com/aws/aws-sdk-go/private/protocol/query"
-	"github.com/aws/aws-sdk-go/private/protocol/rest"
-	"github.com/aws/aws-sdk-go/private/protocol/restjson"
-	"github.com/aws/aws-sdk-go/private/protocol/restxml"
-)
-
-func xmlData(set bool, b []byte, size, delta int) {
-	const openingTags = "<B><A>"
-	const closingTags = "</A></B>"
-	if !set {
-		copy(b, []byte(openingTags))
-	}
-	if size == 0 {
-		copy(b[delta-len(closingTags):], []byte(closingTags))
-	}
-}
-
-func jsonData(set bool, b []byte, size, delta int) {
-	if !set {
-		copy(b, []byte("{\"A\": \""))
-	}
-	if size == 0 {
-		copy(b[delta-len("\"}"):], []byte("\"}"))
-	}
-}
-
-func buildNewRequest(data interface{}) *request.Request {
-	v := url.Values{}
-	v.Set("test", "TEST")
-	v.Add("test1", "TEST1")
-
-	req := &request.Request{
-		HTTPRequest: &http.Request{
-			Header: make(http.Header),
-			Body:   &awstesting.ReadCloser{Size: 2048},
-			URL: &url.URL{
-				RawQuery: v.Encode(),
-			},
-		},
-		Params: &struct {
-			LocationName string `locationName:"test"`
-		}{
-			"Test",
-		},
-		ClientInfo: metadata.ClientInfo{
-			ServiceName:   "test",
-			TargetPrefix:  "test",
-			JSONVersion:   "test",
-			APIVersion:    "test",
-			Endpoint:      "test",
-			SigningName:   "test",
-			SigningRegion: "test",
-		},
-		Operation: &request.Operation{
-			Name: "test",
-		},
-	}
-	req.HTTPResponse = &http.Response{
-		Body: &awstesting.ReadCloser{Size: 2048},
-		Header: http.Header{
-			"X-Amzn-Requestid": []string{"1"},
-		},
-		StatusCode: http.StatusOK,
-	}
-
-	if data == nil {
-		data = &struct {
-			_            struct{} `type:"structure"`
-			LocationName *string  `locationName:"testName"`
-			Location     *string  `location:"statusCode"`
-			A            *string  `type:"string"`
-		}{}
-	}
-
-	req.Data = data
-
-	return req
-}
-
-type expected struct {
-	dataType  int
-	closed    bool
-	size      int
-	errExists bool
-}
-
-const (
-	jsonType = iota
-	xmlType
-)
-
-func checkForLeak(data interface{}, build, fn func(*request.Request), t *testing.T, result expected) {
-	req := buildNewRequest(data)
-	reader := req.HTTPResponse.Body.(*awstesting.ReadCloser)
-	switch result.dataType {
-	case jsonType:
-		reader.FillData = jsonData
-	case xmlType:
-		reader.FillData = xmlData
-	}
-	build(req)
-	fn(req)
-
-	if result.errExists {
-		assert.NotNil(t, req.Error)
-	} else {
-		assert.Nil(t, req.Error)
-	}
-
-	assert.Equal(t, reader.Closed, result.closed)
-	assert.Equal(t, reader.Size, result.size)
-}
-
-func TestJSONRpc(t *testing.T) {
-	checkForLeak(nil, jsonrpc.Build, jsonrpc.Unmarshal, t, expected{jsonType, true, 0, false})
-	checkForLeak(nil, jsonrpc.Build, jsonrpc.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
-	checkForLeak(nil, jsonrpc.Build, jsonrpc.UnmarshalError, t, expected{jsonType, true, 0, true})
-}
-
-func TestQuery(t *testing.T) {
-	checkForLeak(nil, query.Build, query.Unmarshal, t, expected{jsonType, true, 0, false})
-	checkForLeak(nil, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
-	checkForLeak(nil, query.Build, query.UnmarshalError, t, expected{jsonType, true, 0, true})
-}
-
-func TestRest(t *testing.T) {
-	// case 1: Payload io.ReadSeeker
-	checkForLeak(nil, rest.Build, rest.Unmarshal, t, expected{jsonType, false, 2048, false})
-	checkForLeak(nil, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
-
-	// case 2: Payload *string
-	// should close the body
-	dataStr := struct {
-		_            struct{} `type:"structure" payload:"Payload"`
-		LocationName *string  `locationName:"testName"`
-		Location     *string  `location:"statusCode"`
-		A            *string  `type:"string"`
-		Payload      *string  `locationName:"payload" type:"blob" required:"true"`
-	}{}
-	checkForLeak(&dataStr, rest.Build, rest.Unmarshal, t, expected{jsonType, true, 0, false})
-	checkForLeak(&dataStr, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
-
-	// case 3: Payload []byte
-	// should close the body
-	dataBytes := struct {
-		_            struct{} `type:"structure" payload:"Payload"`
-		LocationName *string  `locationName:"testName"`
-		Location     *string  `location:"statusCode"`
-		A            *string  `type:"string"`
-		Payload      []byte   `locationName:"payload" type:"blob" required:"true"`
-	}{}
-	checkForLeak(&dataBytes, rest.Build, rest.Unmarshal, t, expected{jsonType, true, 0, false})
-	checkForLeak(&dataBytes, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
-
-	// case 4: Payload unsupported type
-	// should close the body
-	dataUnsupported := struct {
-		_            struct{} `type:"structure" payload:"Payload"`
-		LocationName *string  `locationName:"testName"`
-		Location     *string  `location:"statusCode"`
-		A            *string  `type:"string"`
-		Payload      string   `locationName:"payload" type:"blob" required:"true"`
-	}{}
-	checkForLeak(&dataUnsupported, rest.Build, rest.Unmarshal, t, expected{jsonType, true, 0, true})
-	checkForLeak(&dataUnsupported, query.Build, query.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
-}
-
-func TestRestJSON(t *testing.T) {
-	checkForLeak(nil, restjson.Build, restjson.Unmarshal, t, expected{jsonType, true, 0, false})
-	checkForLeak(nil, restjson.Build, restjson.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
-	checkForLeak(nil, restjson.Build, restjson.UnmarshalError, t, expected{jsonType, true, 0, true})
-}
-
-func TestRestXML(t *testing.T) {
-	checkForLeak(nil, restxml.Build, restxml.Unmarshal, t, expected{xmlType, true, 0, false})
-	checkForLeak(nil, restxml.Build, restxml.UnmarshalMeta, t, expected{xmlType, false, 2048, false})
-	checkForLeak(nil, restxml.Build, restxml.UnmarshalError, t, expected{xmlType, true, 0, true})
-}
-
-func TestXML(t *testing.T) {
-	checkForLeak(nil, ec2query.Build, ec2query.Unmarshal, t, expected{jsonType, true, 0, false})
-	checkForLeak(nil, ec2query.Build, ec2query.UnmarshalMeta, t, expected{jsonType, false, 2048, false})
-	checkForLeak(nil, ec2query.Build, ec2query.UnmarshalError, t, expected{jsonType, true, 0, true})
-}
-
-func TestProtocol(t *testing.T) {
-	checkForLeak(nil, restxml.Build, protocol.UnmarshalDiscardBody, t, expected{xmlType, true, 0, false})
-}

vendor/github.com/aws/aws-sdk-go/private/protocol/rest/build_test.go

@@ -1,63 +0,0 @@
-package rest
-
-import (
-	"net/http"
-	"net/url"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/request"
-)
-
-func TestCleanPath(t *testing.T) {
-	uri := &url.URL{
-		Path:   "//foo//bar",
-		Scheme: "https",
-		Host:   "host",
-	}
-	cleanPath(uri)
-
-	expected := "https://host/foo/bar"
-	if a, e := uri.String(), expected; a != e {
-		t.Errorf("expect %q URI, got %q", e, a)
-	}
-}
-
-func TestMarshalPath(t *testing.T) {
-	in := struct {
-		Bucket *string `location:"uri" locationName:"bucket"`
-		Key    *string `location:"uri" locationName:"key"`
-	}{
-		Bucket: aws.String("mybucket"),
-		Key:    aws.String("my/cool+thing space/object世界"),
-	}
-
-	expectURL := `/mybucket/my/cool+thing space/object世界`
-	expectEscapedURL := `/mybucket/my/cool%2Bthing%20space/object%E4%B8%96%E7%95%8C`
-
-	req := &request.Request{
-		HTTPRequest: &http.Request{
-			URL: &url.URL{Scheme: "https", Host: "exmaple.com", Path: "/{bucket}/{key+}"},
-		},
-		Params: &in,
-	}
-
-	Build(req)
-
-	if req.Error != nil {
-		t.Fatalf("unexpected error, %v", req.Error)
-	}
-
-	if a, e := req.HTTPRequest.URL.Path, expectURL; a != e {
-		t.Errorf("expect %q URI, got %q", e, a)
-	}
-
-	if a, e := req.HTTPRequest.URL.RawPath, expectEscapedURL; a != e {
-		t.Errorf("expect %q escaped URI, got %q", e, a)
-	}
-
-	if a, e := req.HTTPRequest.URL.EscapedPath(), expectEscapedURL; a != e {
-		t.Errorf("expect %q escaped URI, got %q", e, a)
-	}
-
-}

vendor/github.com/aws/aws-sdk-go/private/protocol/rest/rest_test.go

@@ -1,63 +0,0 @@
-package rest_test
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net/http"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/client"
-	"github.com/aws/aws-sdk-go/aws/client/metadata"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/aws/signer/v4"
-	"github.com/aws/aws-sdk-go/awstesting/unit"
-	"github.com/aws/aws-sdk-go/private/protocol/rest"
-)
-
-func TestUnsetHeaders(t *testing.T) {
-	cfg := &aws.Config{Region: aws.String("us-west-2")}
-	c := unit.Session.ClientConfig("testService", cfg)
-	svc := client.New(
-		*cfg,
-		metadata.ClientInfo{
-			ServiceName:   "testService",
-			SigningName:   c.SigningName,
-			SigningRegion: c.SigningRegion,
-			Endpoint:      c.Endpoint,
-			APIVersion:    "",
-		},
-		c.Handlers,
-	)
-
-	// Handlers
-	svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler)
-	svc.Handlers.Build.PushBackNamed(rest.BuildHandler)
-	svc.Handlers.Unmarshal.PushBackNamed(rest.UnmarshalHandler)
-	svc.Handlers.UnmarshalMeta.PushBackNamed(rest.UnmarshalMetaHandler)
-	op := &request.Operation{
-		Name:     "test-operation",
-		HTTPPath: "/",
-	}
-
-	input := &struct {
-		Foo aws.JSONValue `location:"header" locationName:"x-amz-foo" type:"jsonvalue"`
-		Bar aws.JSONValue `location:"header" locationName:"x-amz-bar" type:"jsonvalue"`
-	}{}
-
-	output := &struct {
-		Foo aws.JSONValue `location:"header" locationName:"x-amz-foo" type:"jsonvalue"`
-		Bar aws.JSONValue `location:"header" locationName:"x-amz-bar" type:"jsonvalue"`
-	}{}
-
-	req := svc.NewRequest(op, input, output)
-	req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(bytes.NewBuffer(nil)), Header: http.Header{}}
-	req.HTTPResponse.Header.Set("X-Amz-Foo", "e30=")
-
-	// unmarshal response
-	rest.UnmarshalMeta(req)
-	rest.Unmarshal(req)
-	if req.Error != nil {
-		t.Fatal(req.Error)
-	}
-}

vendor/github.com/aws/aws-sdk-go/private/protocol/restjson/build_bench_test.go

@@ -1,350 +0,0 @@
-// +build bench
-
-package restjson_test
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/endpoints"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/private/protocol/restjson"
-	"github.com/aws/aws-sdk-go/service/elastictranscoder"
-)
-
-var (
-	elastictranscoderSvc *elastictranscoder.ElasticTranscoder
-)
-
-func TestMain(m *testing.M) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-	}))
-
-	sess := session.Must(session.NewSession(&aws.Config{
-		Credentials:      credentials.NewStaticCredentials("Key", "Secret", "Token"),
-		Endpoint:         aws.String(server.URL),
-		S3ForcePathStyle: aws.Bool(true),
-		DisableSSL:       aws.Bool(true),
-		Region:           aws.String(endpoints.UsWest2RegionID),
-	}))
-	elastictranscoderSvc = elastictranscoder.New(sess)
-
-	c := m.Run()
-	server.Close()
-	os.Exit(c)
-}
-
-func BenchmarkRESTJSONBuild_Complex_ETCCreateJob(b *testing.B) {
-	params := elastictranscoderCreateJobInput()
-
-	benchRESTJSONBuild(b, func() *request.Request {
-		req, _ := elastictranscoderSvc.CreateJobRequest(params)
-		return req
-	})
-}
-
-func BenchmarkRESTJSONBuild_Simple_ETCListJobsByPipeline(b *testing.B) {
-	params := elastictranscoderListJobsByPipeline()
-
-	benchRESTJSONBuild(b, func() *request.Request {
-		req, _ := elastictranscoderSvc.ListJobsByPipelineRequest(params)
-		return req
-	})
-}
-
-func BenchmarkRESTJSONRequest_Complex_CFCreateJob(b *testing.B) {
-	benchRESTJSONRequest(b, func() *request.Request {
-		req, _ := elastictranscoderSvc.CreateJobRequest(elastictranscoderCreateJobInput())
-		return req
-	})
-}
-
-func BenchmarkRESTJSONRequest_Simple_ETCListJobsByPipeline(b *testing.B) {
-	benchRESTJSONRequest(b, func() *request.Request {
-		req, _ := elastictranscoderSvc.ListJobsByPipelineRequest(elastictranscoderListJobsByPipeline())
-		return req
-	})
-}
-
-func benchRESTJSONBuild(b *testing.B, reqFn func() *request.Request) {
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		req := reqFn()
-		restjson.Build(req)
-		if req.Error != nil {
-			b.Fatal("Unexpected error", req.Error)
-		}
-	}
-}
-
-func benchRESTJSONRequest(b *testing.B, reqFn func() *request.Request) {
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		err := reqFn().Send()
-		if err != nil {
-			b.Fatal("Unexpected error", err)
-		}
-	}
-}
-
-func elastictranscoderListJobsByPipeline() *elastictranscoder.ListJobsByPipelineInput {
-	return &elastictranscoder.ListJobsByPipelineInput{
-		PipelineId: aws.String("Id"), // Required
-		Ascending:  aws.String("Ascending"),
-		PageToken:  aws.String("Id"),
-	}
-}
-
-func elastictranscoderCreateJobInput() *elastictranscoder.CreateJobInput {
-	return &elastictranscoder.CreateJobInput{
-		Input: &elastictranscoder.JobInput{ // Required
-			AspectRatio: aws.String("AspectRatio"),
-			Container:   aws.String("JobContainer"),
-			DetectedProperties: &elastictranscoder.DetectedProperties{
-				DurationMillis: aws.Int64(1),
-				FileSize:       aws.Int64(1),
-				FrameRate:      aws.String("FloatString"),
-				Height:         aws.Int64(1),
-				Width:          aws.Int64(1),
-			},
-			Encryption: &elastictranscoder.Encryption{
-				InitializationVector: aws.String("ZeroTo255String"),
-				Key:                  aws.String("Base64EncodedString"),
-				KeyMd5:               aws.String("Base64EncodedString"),
-				Mode:                 aws.String("EncryptionMode"),
-			},
-			FrameRate:  aws.String("FrameRate"),
-			Interlaced: aws.String("Interlaced"),
-			Key:        aws.String("Key"),
-			Resolution: aws.String("Resolution"),
-		},
-		PipelineId: aws.String("Id"), // Required
-		Output: &elastictranscoder.CreateJobOutput{
-			AlbumArt: &elastictranscoder.JobAlbumArt{
-				Artwork: []*elastictranscoder.Artwork{
-					{ // Required
-						AlbumArtFormat: aws.String("JpgOrPng"),
-						Encryption: &elastictranscoder.Encryption{
-							InitializationVector: aws.String("ZeroTo255String"),
-							Key:                  aws.String("Base64EncodedString"),
-							KeyMd5:               aws.String("Base64EncodedString"),
-							Mode:                 aws.String("EncryptionMode"),
-						},
-						InputKey:      aws.String("WatermarkKey"),
-						MaxHeight:     aws.String("DigitsOrAuto"),
-						MaxWidth:      aws.String("DigitsOrAuto"),
-						PaddingPolicy: aws.String("PaddingPolicy"),
-						SizingPolicy:  aws.String("SizingPolicy"),
-					},
-					// More values...
-				},
-				MergePolicy: aws.String("MergePolicy"),
-			},
-			Captions: &elastictranscoder.Captions{
-				CaptionFormats: []*elastictranscoder.CaptionFormat{
-					{ // Required
-						Encryption: &elastictranscoder.Encryption{
-							InitializationVector: aws.String("ZeroTo255String"),
-							Key:                  aws.String("Base64EncodedString"),
-							KeyMd5:               aws.String("Base64EncodedString"),
-							Mode:                 aws.String("EncryptionMode"),
-						},
-						Format:  aws.String("CaptionFormatFormat"),
-						Pattern: aws.String("CaptionFormatPattern"),
-					},
-					// More values...
-				},
-				CaptionSources: []*elastictranscoder.CaptionSource{
-					{ // Required
-						Encryption: &elastictranscoder.Encryption{
-							InitializationVector: aws.String("ZeroTo255String"),
-							Key:                  aws.String("Base64EncodedString"),
-							KeyMd5:               aws.String("Base64EncodedString"),
-							Mode:                 aws.String("EncryptionMode"),
-						},
-						Key:        aws.String("Key"),
-						Label:      aws.String("Name"),
-						Language:   aws.String("Key"),
-						TimeOffset: aws.String("TimeOffset"),
-					},
-					// More values...
-				},
-				MergePolicy: aws.String("CaptionMergePolicy"),
-			},
-			Composition: []*elastictranscoder.Clip{
-				{ // Required
-					TimeSpan: &elastictranscoder.TimeSpan{
-						Duration:  aws.String("Time"),
-						StartTime: aws.String("Time"),
-					},
-				},
-				// More values...
-			},
-			Encryption: &elastictranscoder.Encryption{
-				InitializationVector: aws.String("ZeroTo255String"),
-				Key:                  aws.String("Base64EncodedString"),
-				KeyMd5:               aws.String("Base64EncodedString"),
-				Mode:                 aws.String("EncryptionMode"),
-			},
-			Key:             aws.String("Key"),
-			PresetId:        aws.String("Id"),
-			Rotate:          aws.String("Rotate"),
-			SegmentDuration: aws.String("FloatString"),
-			ThumbnailEncryption: &elastictranscoder.Encryption{
-				InitializationVector: aws.String("ZeroTo255String"),
-				Key:                  aws.String("Base64EncodedString"),
-				KeyMd5:               aws.String("Base64EncodedString"),
-				Mode:                 aws.String("EncryptionMode"),
-			},
-			ThumbnailPattern: aws.String("ThumbnailPattern"),
-			Watermarks: []*elastictranscoder.JobWatermark{
-				{ // Required
-					Encryption: &elastictranscoder.Encryption{
-						InitializationVector: aws.String("ZeroTo255String"),
-						Key:                  aws.String("Base64EncodedString"),
-						KeyMd5:               aws.String("Base64EncodedString"),
-						Mode:                 aws.String("EncryptionMode"),
-					},
-					InputKey:          aws.String("WatermarkKey"),
-					PresetWatermarkId: aws.String("PresetWatermarkId"),
-				},
-				// More values...
-			},
-		},
-		OutputKeyPrefix: aws.String("Key"),
-		Outputs: []*elastictranscoder.CreateJobOutput{
-			{ // Required
-				AlbumArt: &elastictranscoder.JobAlbumArt{
-					Artwork: []*elastictranscoder.Artwork{
-						{ // Required
-							AlbumArtFormat: aws.String("JpgOrPng"),
-							Encryption: &elastictranscoder.Encryption{
-								InitializationVector: aws.String("ZeroTo255String"),
-								Key:                  aws.String("Base64EncodedString"),
-								KeyMd5:               aws.String("Base64EncodedString"),
-								Mode:                 aws.String("EncryptionMode"),
-							},
-							InputKey:      aws.String("WatermarkKey"),
-							MaxHeight:     aws.String("DigitsOrAuto"),
-							MaxWidth:      aws.String("DigitsOrAuto"),
-							PaddingPolicy: aws.String("PaddingPolicy"),
-							SizingPolicy:  aws.String("SizingPolicy"),
-						},
-						// More values...
-					},
-					MergePolicy: aws.String("MergePolicy"),
-				},
-				Captions: &elastictranscoder.Captions{
-					CaptionFormats: []*elastictranscoder.CaptionFormat{
-						{ // Required
-							Encryption: &elastictranscoder.Encryption{
-								InitializationVector: aws.String("ZeroTo255String"),
-								Key:                  aws.String("Base64EncodedString"),
-								KeyMd5:               aws.String("Base64EncodedString"),
-								Mode:                 aws.String("EncryptionMode"),
-							},
-							Format:  aws.String("CaptionFormatFormat"),
-							Pattern: aws.String("CaptionFormatPattern"),
-						},
-						// More values...
-					},
-					CaptionSources: []*elastictranscoder.CaptionSource{
-						{ // Required
-							Encryption: &elastictranscoder.Encryption{
-								InitializationVector: aws.String("ZeroTo255String"),
-								Key:                  aws.String("Base64EncodedString"),
-								KeyMd5:               aws.String("Base64EncodedString"),
-								Mode:                 aws.String("EncryptionMode"),
-							},
-							Key:        aws.String("Key"),
-							Label:      aws.String("Name"),
-							Language:   aws.String("Key"),
-							TimeOffset: aws.String("TimeOffset"),
-						},
-						// More values...
-					},
-					MergePolicy: aws.String("CaptionMergePolicy"),
-				},
-				Composition: []*elastictranscoder.Clip{
-					{ // Required
-						TimeSpan: &elastictranscoder.TimeSpan{
-							Duration:  aws.String("Time"),
-							StartTime: aws.String("Time"),
-						},
-					},
-					// More values...
-				},
-				Encryption: &elastictranscoder.Encryption{
-					InitializationVector: aws.String("ZeroTo255String"),
-					Key:                  aws.String("Base64EncodedString"),
-					KeyMd5:               aws.String("Base64EncodedString"),
-					Mode:                 aws.String("EncryptionMode"),
-				},
-				Key:             aws.String("Key"),
-				PresetId:        aws.String("Id"),
-				Rotate:          aws.String("Rotate"),
-				SegmentDuration: aws.String("FloatString"),
-				ThumbnailEncryption: &elastictranscoder.Encryption{
-					InitializationVector: aws.String("ZeroTo255String"),
-					Key:                  aws.String("Base64EncodedString"),
-					KeyMd5:               aws.String("Base64EncodedString"),
-					Mode:                 aws.String("EncryptionMode"),
-				},
-				ThumbnailPattern: aws.String("ThumbnailPattern"),
-				Watermarks: []*elastictranscoder.JobWatermark{
-					{ // Required
-						Encryption: &elastictranscoder.Encryption{
-							InitializationVector: aws.String("ZeroTo255String"),
-							Key:                  aws.String("Base64EncodedString"),
-							KeyMd5:               aws.String("Base64EncodedString"),
-							Mode:                 aws.String("EncryptionMode"),
-						},
-						InputKey:          aws.String("WatermarkKey"),
-						PresetWatermarkId: aws.String("PresetWatermarkId"),
-					},
-					// More values...
-				},
-			},
-			// More values...
-		},
-		Playlists: []*elastictranscoder.CreateJobPlaylist{
-			{ // Required
-				Format: aws.String("PlaylistFormat"),
-				HlsContentProtection: &elastictranscoder.HlsContentProtection{
-					InitializationVector:  aws.String("ZeroTo255String"),
-					Key:                   aws.String("Base64EncodedString"),
-					KeyMd5:                aws.String("Base64EncodedString"),
-					KeyStoragePolicy:      aws.String("KeyStoragePolicy"),
-					LicenseAcquisitionUrl: aws.String("ZeroTo512String"),
-					Method:                aws.String("HlsContentProtectionMethod"),
-				},
-				Name: aws.String("Filename"),
-				OutputKeys: []*string{
-					aws.String("Key"), // Required
-					// More values...
-				},
-				PlayReadyDrm: &elastictranscoder.PlayReadyDrm{
-					Format:                aws.String("PlayReadyDrmFormatString"),
-					InitializationVector:  aws.String("ZeroTo255String"),
-					Key:                   aws.String("NonEmptyBase64EncodedString"),
-					KeyId:                 aws.String("KeyIdGuid"),
-					KeyMd5:                aws.String("NonEmptyBase64EncodedString"),
-					LicenseAcquisitionUrl: aws.String("OneTo512String"),
-				},
-			},
-			// More values...
-		},
-		UserMetadata: map[string]*string{
-			"Key": aws.String("String"), // Required
-			// More values...
-		},
-	}
-}

vendor/github.com/aws/aws-sdk-go/private/protocol/restjson/restjson.go

@@ -1,92 +0,0 @@
-// Package restjson provides RESTful JSON serialization of AWS
-// requests and responses.
-package restjson
-
-//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/input/rest-json.json build_test.go
-//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/output/rest-json.json unmarshal_test.go
-
-import (
-	"encoding/json"
-	"io/ioutil"
-	"strings"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/private/protocol/jsonrpc"
-	"github.com/aws/aws-sdk-go/private/protocol/rest"
-)
-
-// BuildHandler is a named request handler for building restjson protocol requests
-var BuildHandler = request.NamedHandler{Name: "awssdk.restjson.Build", Fn: Build}
-
-// UnmarshalHandler is a named request handler for unmarshaling restjson protocol requests
-var UnmarshalHandler = request.NamedHandler{Name: "awssdk.restjson.Unmarshal", Fn: Unmarshal}
-
-// UnmarshalMetaHandler is a named request handler for unmarshaling restjson protocol request metadata
-var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.restjson.UnmarshalMeta", Fn: UnmarshalMeta}
-
-// UnmarshalErrorHandler is a named request handler for unmarshaling restjson protocol request errors
-var UnmarshalErrorHandler = request.NamedHandler{Name: "awssdk.restjson.UnmarshalError", Fn: UnmarshalError}
-
-// Build builds a request for the REST JSON protocol.
-func Build(r *request.Request) {
-	rest.Build(r)
-
-	if t := rest.PayloadType(r.Params); t == "structure" || t == "" {
-		jsonrpc.Build(r)
-	}
-}
-
-// Unmarshal unmarshals a response body for the REST JSON protocol.
-func Unmarshal(r *request.Request) {
-	if t := rest.PayloadType(r.Data); t == "structure" || t == "" {
-		jsonrpc.Unmarshal(r)
-	} else {
-		rest.Unmarshal(r)
-	}
-}
-
-// UnmarshalMeta unmarshals response headers for the REST JSON protocol.
-func UnmarshalMeta(r *request.Request) {
-	rest.UnmarshalMeta(r)
-}
-
-// UnmarshalError unmarshals a response error for the REST JSON protocol.
-func UnmarshalError(r *request.Request) {
-	defer r.HTTPResponse.Body.Close()
-	code := r.HTTPResponse.Header.Get("X-Amzn-Errortype")
-	bodyBytes, err := ioutil.ReadAll(r.HTTPResponse.Body)
-	if err != nil {
-		r.Error = awserr.New("SerializationError", "failed reading REST JSON error response", err)
-		return
-	}
-	if len(bodyBytes) == 0 {
-		r.Error = awserr.NewRequestFailure(
-			awserr.New("SerializationError", r.HTTPResponse.Status, nil),
-			r.HTTPResponse.StatusCode,
-			"",
-		)
-		return
-	}
-	var jsonErr jsonErrorResponse
-	if err := json.Unmarshal(bodyBytes, &jsonErr); err != nil {
-		r.Error = awserr.New("SerializationError", "failed decoding REST JSON error response", err)
-		return
-	}
-
-	if code == "" {
-		code = jsonErr.Code
-	}
-
-	code = strings.SplitN(code, ":", 2)[0]
-	r.Error = awserr.NewRequestFailure(
-		awserr.New(code, jsonErr.Message, nil),
-		r.HTTPResponse.StatusCode,
-		r.RequestID,
-	)
-}
-
-type jsonErrorResponse struct {
-	Code    string `json:"code"`
-	Message string `json:"message"`
-}

vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/build_bench_test.go

@@ -1,366 +0,0 @@
-// +build bench
-
-package restxml_test
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"testing"
-
-	"bytes"
-	"encoding/xml"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/credentials"
-	"github.com/aws/aws-sdk-go/aws/endpoints"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/aws/session"
-	"github.com/aws/aws-sdk-go/private/protocol/restxml"
-	"github.com/aws/aws-sdk-go/service/cloudfront"
-	"github.com/aws/aws-sdk-go/service/s3"
-)
-
-var (
-	cloudfrontSvc *cloudfront.CloudFront
-	s3Svc         *s3.S3
-)
-
-func TestMain(m *testing.M) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-	}))
-
-	sess := session.Must(session.NewSession(&aws.Config{
-		Credentials:      credentials.NewStaticCredentials("Key", "Secret", "Token"),
-		Endpoint:         aws.String(server.URL),
-		S3ForcePathStyle: aws.Bool(true),
-		DisableSSL:       aws.Bool(true),
-		Region:           aws.String(endpoints.UsWest2RegionID),
-	}))
-	cloudfrontSvc = cloudfront.New(sess)
-	s3Svc = s3.New(sess)
-
-	c := m.Run()
-	server.Close()
-	os.Exit(c)
-}
-
-func BenchmarkRESTXMLBuild_Complex_CFCreateDistro(b *testing.B) {
-	params := cloudfrontCreateDistributionInput()
-
-	benchRESTXMLBuild(b, func() *request.Request {
-		req, _ := cloudfrontSvc.CreateDistributionRequest(params)
-		return req
-	})
-}
-
-func BenchmarkRESTXMLBuild_Simple_CFDeleteDistro(b *testing.B) {
-	params := cloudfrontDeleteDistributionInput()
-
-	benchRESTXMLBuild(b, func() *request.Request {
-		req, _ := cloudfrontSvc.DeleteDistributionRequest(params)
-		return req
-	})
-}
-
-func BenchmarkRESTXMLBuild_REST_S3HeadObject(b *testing.B) {
-	params := s3HeadObjectInput()
-
-	benchRESTXMLBuild(b, func() *request.Request {
-		req, _ := s3Svc.HeadObjectRequest(params)
-		return req
-	})
-}
-
-func BenchmarkRESTXMLBuild_XML_S3PutObjectAcl(b *testing.B) {
-	params := s3PutObjectAclInput()
-
-	benchRESTXMLBuild(b, func() *request.Request {
-		req, _ := s3Svc.PutObjectAclRequest(params)
-		return req
-	})
-}
-
-func BenchmarkRESTXMLRequest_Complex_CFCreateDistro(b *testing.B) {
-	benchRESTXMLRequest(b, func() *request.Request {
-		req, _ := cloudfrontSvc.CreateDistributionRequest(cloudfrontCreateDistributionInput())
-		return req
-	})
-}
-
-func BenchmarkRESTXMLRequest_Simple_CFDeleteDistro(b *testing.B) {
-	benchRESTXMLRequest(b, func() *request.Request {
-		req, _ := cloudfrontSvc.DeleteDistributionRequest(cloudfrontDeleteDistributionInput())
-		return req
-	})
-}
-
-func BenchmarkRESTXMLRequest_REST_S3HeadObject(b *testing.B) {
-	benchRESTXMLRequest(b, func() *request.Request {
-		req, _ := s3Svc.HeadObjectRequest(s3HeadObjectInput())
-		return req
-	})
-}
-
-func BenchmarkRESTXMLRequest_XML_S3PutObjectAcl(b *testing.B) {
-	benchRESTXMLRequest(b, func() *request.Request {
-		req, _ := s3Svc.PutObjectAclRequest(s3PutObjectAclInput())
-		return req
-	})
-}
-
-func BenchmarkEncodingXML_Simple(b *testing.B) {
-	params := cloudfrontDeleteDistributionInput()
-
-	for i := 0; i < b.N; i++ {
-		buf := &bytes.Buffer{}
-		encoder := xml.NewEncoder(buf)
-		if err := encoder.Encode(params); err != nil {
-			b.Fatal("Unexpected error", err)
-		}
-	}
-}
-
-func benchRESTXMLBuild(b *testing.B, reqFn func() *request.Request) {
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		req := reqFn()
-		restxml.Build(req)
-		if req.Error != nil {
-			b.Fatal("Unexpected error", req.Error)
-		}
-	}
-}
-
-func benchRESTXMLRequest(b *testing.B, reqFn func() *request.Request) {
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		err := reqFn().Send()
-		if err != nil {
-			b.Fatal("Unexpected error", err)
-		}
-	}
-}
-
-func cloudfrontCreateDistributionInput() *cloudfront.CreateDistributionInput {
-	return &cloudfront.CreateDistributionInput{
-		DistributionConfig: &cloudfront.DistributionConfig{ // Required
-			CallerReference: aws.String("string"), // Required
-			Comment:         aws.String("string"), // Required
-			DefaultCacheBehavior: &cloudfront.DefaultCacheBehavior{ // Required
-				ForwardedValues: &cloudfront.ForwardedValues{ // Required
-					Cookies: &cloudfront.CookiePreference{ // Required
-						Forward: aws.String("ItemSelection"), // Required
-						WhitelistedNames: &cloudfront.CookieNames{
-							Quantity: aws.Int64(1), // Required
-							Items: []*string{
-								aws.String("string"), // Required
-								// More values...
-							},
-						},
-					},
-					QueryString: aws.Bool(true), // Required
-					Headers: &cloudfront.Headers{
-						Quantity: aws.Int64(1), // Required
-						Items: []*string{
-							aws.String("string"), // Required
-							// More values...
-						},
-					},
-				},
-				MinTTL:         aws.Int64(1),         // Required
-				TargetOriginId: aws.String("string"), // Required
-				TrustedSigners: &cloudfront.TrustedSigners{ // Required
-					Enabled:  aws.Bool(true), // Required
-					Quantity: aws.Int64(1),   // Required
-					Items: []*string{
-						aws.String("string"), // Required
-						// More values...
-					},
-				},
-				ViewerProtocolPolicy: aws.String("ViewerProtocolPolicy"), // Required
-				AllowedMethods: &cloudfront.AllowedMethods{
-					Items: []*string{ // Required
-						aws.String("Method"), // Required
-						// More values...
-					},
-					Quantity: aws.Int64(1), // Required
-					CachedMethods: &cloudfront.CachedMethods{
-						Items: []*string{ // Required
-							aws.String("Method"), // Required
-							// More values...
-						},
-						Quantity: aws.Int64(1), // Required
-					},
-				},
-				DefaultTTL:      aws.Int64(1),
-				MaxTTL:          aws.Int64(1),
-				SmoothStreaming: aws.Bool(true),
-			},
-			Enabled: aws.Bool(true), // Required
-			Origins: &cloudfront.Origins{ // Required
-				Quantity: aws.Int64(1), // Required
-				Items: []*cloudfront.Origin{
-					{ // Required
-						DomainName: aws.String("string"), // Required
-						Id:         aws.String("string"), // Required
-						CustomOriginConfig: &cloudfront.CustomOriginConfig{
-							HTTPPort:             aws.Int64(1),                       // Required
-							HTTPSPort:            aws.Int64(1),                       // Required
-							OriginProtocolPolicy: aws.String("OriginProtocolPolicy"), // Required
-						},
-						OriginPath: aws.String("string"),
-						S3OriginConfig: &cloudfront.S3OriginConfig{
-							OriginAccessIdentity: aws.String("string"), // Required
-						},
-					},
-					// More values...
-				},
-			},
-			Aliases: &cloudfront.Aliases{
-				Quantity: aws.Int64(1), // Required
-				Items: []*string{
-					aws.String("string"), // Required
-					// More values...
-				},
-			},
-			CacheBehaviors: &cloudfront.CacheBehaviors{
-				Quantity: aws.Int64(1), // Required
-				Items: []*cloudfront.CacheBehavior{
-					{ // Required
-						ForwardedValues: &cloudfront.ForwardedValues{ // Required
-							Cookies: &cloudfront.CookiePreference{ // Required
-								Forward: aws.String("ItemSelection"), // Required
-								WhitelistedNames: &cloudfront.CookieNames{
-									Quantity: aws.Int64(1), // Required
-									Items: []*string{
-										aws.String("string"), // Required
-										// More values...
-									},
-								},
-							},
-							QueryString: aws.Bool(true), // Required
-							Headers: &cloudfront.Headers{
-								Quantity: aws.Int64(1), // Required
-								Items: []*string{
-									aws.String("string"), // Required
-									// More values...
-								},
-							},
-						},
-						MinTTL:         aws.Int64(1),         // Required
-						PathPattern:    aws.String("string"), // Required
-						TargetOriginId: aws.String("string"), // Required
-						TrustedSigners: &cloudfront.TrustedSigners{ // Required
-							Enabled:  aws.Bool(true), // Required
-							Quantity: aws.Int64(1),   // Required
-							Items: []*string{
-								aws.String("string"), // Required
-								// More values...
-							},
-						},
-						ViewerProtocolPolicy: aws.String("ViewerProtocolPolicy"), // Required
-						AllowedMethods: &cloudfront.AllowedMethods{
-							Items: []*string{ // Required
-								aws.String("Method"), // Required
-								// More values...
-							},
-							Quantity: aws.Int64(1), // Required
-							CachedMethods: &cloudfront.CachedMethods{
-								Items: []*string{ // Required
-									aws.String("Method"), // Required
-									// More values...
-								},
-								Quantity: aws.Int64(1), // Required
-							},
-						},
-						DefaultTTL:      aws.Int64(1),
-						MaxTTL:          aws.Int64(1),
-						SmoothStreaming: aws.Bool(true),
-					},
-					// More values...
-				},
-			},
-			CustomErrorResponses: &cloudfront.CustomErrorResponses{
-				Quantity: aws.Int64(1), // Required
-				Items: []*cloudfront.CustomErrorResponse{
-					{ // Required
-						ErrorCode:          aws.Int64(1), // Required
-						ErrorCachingMinTTL: aws.Int64(1),
-						ResponseCode:       aws.String("string"),
-						ResponsePagePath:   aws.String("string"),
-					},
-					// More values...
-				},
-			},
-			DefaultRootObject: aws.String("string"),
-			Logging: &cloudfront.LoggingConfig{
-				Bucket:         aws.String("string"), // Required
-				Enabled:        aws.Bool(true),       // Required
-				IncludeCookies: aws.Bool(true),       // Required
-				Prefix:         aws.String("string"), // Required
-			},
-			PriceClass: aws.String("PriceClass"),
-			Restrictions: &cloudfront.Restrictions{
-				GeoRestriction: &cloudfront.GeoRestriction{ // Required
-					Quantity:        aws.Int64(1),                     // Required
-					RestrictionType: aws.String("GeoRestrictionType"), // Required
-					Items: []*string{
-						aws.String("string"), // Required
-						// More values...
-					},
-				},
-			},
-			ViewerCertificate: &cloudfront.ViewerCertificate{
-				CloudFrontDefaultCertificate: aws.Bool(true),
-				IAMCertificateId:             aws.String("string"),
-				MinimumProtocolVersion:       aws.String("MinimumProtocolVersion"),
-				SSLSupportMethod:             aws.String("SSLSupportMethod"),
-			},
-		},
-	}
-}
-
-func cloudfrontDeleteDistributionInput() *cloudfront.DeleteDistributionInput {
-	return &cloudfront.DeleteDistributionInput{
-		Id:      aws.String("string"), // Required
-		IfMatch: aws.String("string"),
-	}
-}
-
-func s3HeadObjectInput() *s3.HeadObjectInput {
-	return &s3.HeadObjectInput{
-		Bucket:    aws.String("somebucketname"),
-		Key:       aws.String("keyname"),
-		VersionId: aws.String("someVersion"),
-		IfMatch:   aws.String("IfMatch"),
-	}
-}
-
-func s3PutObjectAclInput() *s3.PutObjectAclInput {
-	return &s3.PutObjectAclInput{
-		Bucket: aws.String("somebucketname"),
-		Key:    aws.String("keyname"),
-		AccessControlPolicy: &s3.AccessControlPolicy{
-			Grants: []*s3.Grant{
-				{
-					Grantee: &s3.Grantee{
-						DisplayName:  aws.String("someName"),
-						EmailAddress: aws.String("someAddr"),
-						ID:           aws.String("someID"),
-						Type:         aws.String(s3.TypeCanonicalUser),
-						URI:          aws.String("someURI"),
-					},
-					Permission: aws.String(s3.PermissionWrite),
-				},
-			},
-			Owner: &s3.Owner{
-				DisplayName: aws.String("howdy"),
-				ID:          aws.String("someID"),
-			},
-		},
-	}
-}

vendor/github.com/aws/aws-sdk-go/private/protocol/restxml/restxml.go

@@ -1,69 +0,0 @@
-// Package restxml provides RESTful XML serialization of AWS
-// requests and responses.
-package restxml
-
-//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/input/rest-xml.json build_test.go
-//go:generate go run -tags codegen ../../../models/protocol_tests/generate.go ../../../models/protocol_tests/output/rest-xml.json unmarshal_test.go
-
-import (
-	"bytes"
-	"encoding/xml"
-
-	"github.com/aws/aws-sdk-go/aws/awserr"
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/private/protocol/query"
-	"github.com/aws/aws-sdk-go/private/protocol/rest"
-	"github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil"
-)
-
-// BuildHandler is a named request handler for building restxml protocol requests
-var BuildHandler = request.NamedHandler{Name: "awssdk.restxml.Build", Fn: Build}
-
-// UnmarshalHandler is a named request handler for unmarshaling restxml protocol requests
-var UnmarshalHandler = request.NamedHandler{Name: "awssdk.restxml.Unmarshal", Fn: Unmarshal}
-
-// UnmarshalMetaHandler is a named request handler for unmarshaling restxml protocol request metadata
-var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.restxml.UnmarshalMeta", Fn: UnmarshalMeta}
-
-// UnmarshalErrorHandler is a named request handler for unmarshaling restxml protocol request errors
-var UnmarshalErrorHandler = request.NamedHandler{Name: "awssdk.restxml.UnmarshalError", Fn: UnmarshalError}
-
-// Build builds a request payload for the REST XML protocol.
-func Build(r *request.Request) {
-	rest.Build(r)
-
-	if t := rest.PayloadType(r.Params); t == "structure" || t == "" {
-		var buf bytes.Buffer
-		err := xmlutil.BuildXML(r.Params, xml.NewEncoder(&buf))
-		if err != nil {
-			r.Error = awserr.New("SerializationError", "failed to encode rest XML request", err)
-			return
-		}
-		r.SetBufferBody(buf.Bytes())
-	}
-}
-
-// Unmarshal unmarshals a payload response for the REST XML protocol.
-func Unmarshal(r *request.Request) {
-	if t := rest.PayloadType(r.Data); t == "structure" || t == "" {
-		defer r.HTTPResponse.Body.Close()
-		decoder := xml.NewDecoder(r.HTTPResponse.Body)
-		err := xmlutil.UnmarshalXML(r.Data, decoder, "")
-		if err != nil {
-			r.Error = awserr.New("SerializationError", "failed to decode REST XML response", err)
-			return
-		}
-	} else {
-		rest.Unmarshal(r)
-	}
-}
-
-// UnmarshalMeta unmarshals response headers for the REST XML protocol.
-func UnmarshalMeta(r *request.Request) {
-	rest.UnmarshalMeta(r)
-}
-
-// UnmarshalError unmarshals a response error for the REST XML protocol.
-func UnmarshalError(r *request.Request) {
-	query.UnmarshalError(r)
-}

vendor/github.com/aws/aws-sdk-go/private/protocol/unmarshal_test.go

@@ -1,40 +0,0 @@
-package protocol_test
-
-import (
-	"net/http"
-	"strings"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws/request"
-	"github.com/aws/aws-sdk-go/private/protocol"
-	"github.com/stretchr/testify/assert"
-)
-
-type mockCloser struct {
-	*strings.Reader
-	Closed bool
-}
-
-func (m *mockCloser) Close() error {
-	m.Closed = true
-	return nil
-}
-
-func TestUnmarshalDrainBody(t *testing.T) {
-	b := &mockCloser{Reader: strings.NewReader("example body")}
-	r := &request.Request{HTTPResponse: &http.Response{
-		Body: b,
-	}}
-
-	protocol.UnmarshalDiscardBody(r)
-	assert.NoError(t, r.Error)
-	assert.Equal(t, 0, b.Len())
-	assert.True(t, b.Closed)
-}
-
-func TestUnmarshalDrainBodyNoBody(t *testing.T) {
-	r := &request.Request{HTTPResponse: &http.Response{}}
-
-	protocol.UnmarshalDiscardBody(r)
-	assert.NoError(t, r.Error)
-}

vendor/github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil/unmarshal_test.go

@@ -1,142 +0,0 @@
-package xmlutil
-
-import (
-	"encoding/xml"
-	"fmt"
-	"io"
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/aws/aws-sdk-go/aws"
-	"github.com/aws/aws-sdk-go/aws/awsutil"
-)
-
-type mockBody struct {
-	DoneErr error
-	Body    io.Reader
-}
-
-func (m *mockBody) Read(p []byte) (int, error) {
-	n, err := m.Body.Read(p)
-	if (n == 0 || err == io.EOF) && m.DoneErr != nil {
-		return n, m.DoneErr
-	}
-
-	return n, err
-}
-
-type mockOutput struct {
-	_       struct{}          `type:"structure"`
-	String  *string           `type:"string"`
-	Integer *int64            `type:"integer"`
-	Nested  *mockNestedStruct `type:"structure"`
-	List    []*mockListElem   `locationName:"List" locationNameList:"Elem" type:"list"`
-	Closed  *mockClosedTags   `type:"structure"`
-}
-type mockNestedStruct struct {
-	_            struct{} `type:"structure"`
-	NestedString *string  `type:"string"`
-	NestedInt    *int64   `type:"integer"`
-}
-type mockClosedTags struct {
-	_    struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`
-	Attr *string  `locationName:"xsi:attrval" type:"string" xmlAttribute:"true"`
-}
-type mockListElem struct {
-	_          struct{}            `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`
-	String     *string             `type:"string"`
-	NestedElem *mockNestedListElem `type:"structure"`
-}
-type mockNestedListElem struct {
-	_ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"`
-
-	String *string `type:"string"`
-	Type   *string `locationName:"xsi:type" type:"string" xmlAttribute:"true"`
-}
-
-func TestUnmarshal(t *testing.T) {
-	const xmlBodyStr = `<?xml version="1.0" encoding="UTF-8"?>
-<MockResponse xmlns="http://xmlns.example.com">
-	<String>string value</String>
-	<Integer>123</Integer>
-	<Closed xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:attrval="attr value"/>
-	<Nested>
-		<NestedString>nested string value</NestedString>
-		<NestedInt>321</NestedInt>
-	</Nested>
-	<List>
-		<Elem>
-			<NestedElem xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="type">
-				<String>nested elem string value</String>
-			</NestedElem>
-			<String>elem string value</String>
-		</Elem>
-	</List>
-</MockResponse>`
-
-	expect := mockOutput{
-		String:  aws.String("string value"),
-		Integer: aws.Int64(123),
-		Closed: &mockClosedTags{
-			Attr: aws.String("attr value"),
-		},
-		Nested: &mockNestedStruct{
-			NestedString: aws.String("nested string value"),
-			NestedInt:    aws.Int64(321),
-		},
-		List: []*mockListElem{
-			{
-				String: aws.String("elem string value"),
-				NestedElem: &mockNestedListElem{
-					String: aws.String("nested elem string value"),
-					Type:   aws.String("type"),
-				},
-			},
-		},
-	}
-
-	actual := mockOutput{}
-	decoder := xml.NewDecoder(strings.NewReader(xmlBodyStr))
-	err := UnmarshalXML(&actual, decoder, "")
-	if err != nil {
-		t.Fatalf("expect no error, got %v", err)
-	}
-
-	if !reflect.DeepEqual(expect, actual) {
-		t.Errorf("expect unmarshal to match\nExpect: %s\nActual: %s",
-			awsutil.Prettify(expect), awsutil.Prettify(actual))
-	}
-}
-
-func TestUnmarshal_UnexpectedEOF(t *testing.T) {
-	const partialXMLBody = `<?xml version="1.0" encoding="UTF-8"?>
-	<First>first value</First>
-	<Second>Second val`
-
-	out := struct {
-		First  *string `locationName:"First" type:"string"`
-		Second *string `locationName:"Second" type:"string"`
-	}{}
-
-	expect := out
-	expect.First = aws.String("first")
-	expect.Second = aws.String("second")
-
-	expectErr := fmt.Errorf("expected read error")
-
-	body := &mockBody{
-		DoneErr: expectErr,
-		Body:    strings.NewReader(partialXMLBody),
-	}
-
-	decoder := xml.NewDecoder(body)
-	err := UnmarshalXML(&out, decoder, "")
-
-	if err == nil {
-		t.Fatalf("expect error, got none")
-	}
-	if e, a := expectErr, err; e != a {
-		t.Errorf("expect %v error in %v, but was not", e, a)
-	}
-}