package restxml_test import ( "bytes" "encoding/json" "encoding/xml" "io" "io/ioutil" "net/http" "net/url" "testing" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/defaults" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/aws/service" "github.com/aws/aws-sdk-go/aws/service/serviceinfo" "github.com/aws/aws-sdk-go/internal/protocol/restxml" "github.com/aws/aws-sdk-go/internal/protocol/xml/xmlutil" "github.com/aws/aws-sdk-go/internal/signer/v4" "github.com/aws/aws-sdk-go/internal/util" "github.com/stretchr/testify/assert" ) var _ bytes.Buffer // always import bytes var _ http.Request var _ json.Marshaler var _ time.Time var _ xmlutil.XMLNode var _ xml.Attr var _ = ioutil.Discard var _ = util.Trim("") var _ = url.Values{} var _ = io.EOF type InputService1ProtocolTest struct { *service.Service } // New returns a new InputService1ProtocolTest client. func NewInputService1ProtocolTest(config *aws.Config) *InputService1ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice1protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService1ProtocolTest{service} } // newRequest creates a new request for a InputService1ProtocolTest operation and runs any // custom request initialization. func (c *InputService1ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService1TestCaseOperation1 = "OperationName" // InputService1TestCaseOperation1Request generates a request for the InputService1TestCaseOperation1 operation. func (c *InputService1ProtocolTest) InputService1TestCaseOperation1Request(input *InputService1TestShapeInputShape) (req *request.Request, output *InputService1TestShapeInputService1TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService1TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService1TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService1TestShapeInputService1TestCaseOperation1Output{} req.Data = output return } func (c *InputService1ProtocolTest) InputService1TestCaseOperation1(input *InputService1TestShapeInputShape) (*InputService1TestShapeInputService1TestCaseOperation1Output, error) { req, out := c.InputService1TestCaseOperation1Request(input) err := req.Send() return out, err } const opInputService1TestCaseOperation2 = "OperationName" // InputService1TestCaseOperation2Request generates a request for the InputService1TestCaseOperation2 operation. func (c *InputService1ProtocolTest) InputService1TestCaseOperation2Request(input *InputService1TestShapeInputShape) (req *request.Request, output *InputService1TestShapeInputService1TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService1TestCaseOperation2, HTTPMethod: "PUT", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService1TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService1TestShapeInputService1TestCaseOperation2Output{} req.Data = output return } func (c *InputService1ProtocolTest) InputService1TestCaseOperation2(input *InputService1TestShapeInputShape) (*InputService1TestShapeInputService1TestCaseOperation2Output, error) { req, out := c.InputService1TestCaseOperation2Request(input) err := req.Send() return out, err } type InputService1TestShapeInputService1TestCaseOperation1Output struct { metadataInputService1TestShapeInputService1TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService1TestShapeInputService1TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService1TestShapeInputService1TestCaseOperation2Output struct { metadataInputService1TestShapeInputService1TestCaseOperation2Output `json:"-" xml:"-"` } type metadataInputService1TestShapeInputService1TestCaseOperation2Output struct { SDKShapeTraits bool `type:"structure"` } type InputService1TestShapeInputShape struct { Description *string `type:"string"` Name *string `type:"string"` metadataInputService1TestShapeInputShape `json:"-" xml:"-"` } type metadataInputService1TestShapeInputShape struct { SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` } type InputService2ProtocolTest struct { *service.Service } // New returns a new InputService2ProtocolTest client. func NewInputService2ProtocolTest(config *aws.Config) *InputService2ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice2protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService2ProtocolTest{service} } // newRequest creates a new request for a InputService2ProtocolTest operation and runs any // custom request initialization. func (c *InputService2ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService2TestCaseOperation1 = "OperationName" // InputService2TestCaseOperation1Request generates a request for the InputService2TestCaseOperation1 operation. func (c *InputService2ProtocolTest) InputService2TestCaseOperation1Request(input *InputService2TestShapeInputService2TestCaseOperation1Input) (req *request.Request, output *InputService2TestShapeInputService2TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService2TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService2TestShapeInputService2TestCaseOperation1Input{} } req = c.newRequest(op, input, output) output = &InputService2TestShapeInputService2TestCaseOperation1Output{} req.Data = output return } func (c *InputService2ProtocolTest) InputService2TestCaseOperation1(input *InputService2TestShapeInputService2TestCaseOperation1Input) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) { req, out := c.InputService2TestCaseOperation1Request(input) err := req.Send() return out, err } type InputService2TestShapeInputService2TestCaseOperation1Input struct { First *bool `type:"boolean"` Fourth *int64 `type:"integer"` Second *bool `type:"boolean"` Third *float64 `type:"float"` metadataInputService2TestShapeInputService2TestCaseOperation1Input `json:"-" xml:"-"` } type metadataInputService2TestShapeInputService2TestCaseOperation1Input struct { SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` } type InputService2TestShapeInputService2TestCaseOperation1Output struct { metadataInputService2TestShapeInputService2TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService2TestShapeInputService2TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService3ProtocolTest struct { *service.Service } // New returns a new InputService3ProtocolTest client. func NewInputService3ProtocolTest(config *aws.Config) *InputService3ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice3protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService3ProtocolTest{service} } // newRequest creates a new request for a InputService3ProtocolTest operation and runs any // custom request initialization. func (c *InputService3ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService3TestCaseOperation1 = "OperationName" // InputService3TestCaseOperation1Request generates a request for the InputService3TestCaseOperation1 operation. func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputService3TestCaseOperation1Input) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService3TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService3TestShapeInputService3TestCaseOperation1Input{} } req = c.newRequest(op, input, output) output = &InputService3TestShapeInputService3TestCaseOperation1Output{} req.Data = output return } func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputService3TestCaseOperation1Input) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) { req, out := c.InputService3TestCaseOperation1Request(input) err := req.Send() return out, err } type InputService3TestShapeInputService3TestCaseOperation1Input struct { Description *string `type:"string"` SubStructure *InputService3TestShapeSubStructure `type:"structure"` metadataInputService3TestShapeInputService3TestCaseOperation1Input `json:"-" xml:"-"` } type metadataInputService3TestShapeInputService3TestCaseOperation1Input struct { SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` } type InputService3TestShapeInputService3TestCaseOperation1Output struct { metadataInputService3TestShapeInputService3TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService3TestShapeInputService3TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService3TestShapeSubStructure struct { Bar *string `type:"string"` Foo *string `type:"string"` metadataInputService3TestShapeSubStructure `json:"-" xml:"-"` } type metadataInputService3TestShapeSubStructure struct { SDKShapeTraits bool `type:"structure"` } type InputService4ProtocolTest struct { *service.Service } // New returns a new InputService4ProtocolTest client. func NewInputService4ProtocolTest(config *aws.Config) *InputService4ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice4protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService4ProtocolTest{service} } // newRequest creates a new request for a InputService4ProtocolTest operation and runs any // custom request initialization. func (c *InputService4ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService4TestCaseOperation1 = "OperationName" // InputService4TestCaseOperation1Request generates a request for the InputService4TestCaseOperation1 operation. func (c *InputService4ProtocolTest) InputService4TestCaseOperation1Request(input *InputService4TestShapeInputService4TestCaseOperation1Input) (req *request.Request, output *InputService4TestShapeInputService4TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService4TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService4TestShapeInputService4TestCaseOperation1Input{} } req = c.newRequest(op, input, output) output = &InputService4TestShapeInputService4TestCaseOperation1Output{} req.Data = output return } func (c *InputService4ProtocolTest) InputService4TestCaseOperation1(input *InputService4TestShapeInputService4TestCaseOperation1Input) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) { req, out := c.InputService4TestCaseOperation1Request(input) err := req.Send() return out, err } type InputService4TestShapeInputService4TestCaseOperation1Input struct { Description *string `type:"string"` SubStructure *InputService4TestShapeSubStructure `type:"structure"` metadataInputService4TestShapeInputService4TestCaseOperation1Input `json:"-" xml:"-"` } type metadataInputService4TestShapeInputService4TestCaseOperation1Input struct { SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` } type InputService4TestShapeInputService4TestCaseOperation1Output struct { metadataInputService4TestShapeInputService4TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService4TestShapeInputService4TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService4TestShapeSubStructure struct { Bar *string `type:"string"` Foo *string `type:"string"` metadataInputService4TestShapeSubStructure `json:"-" xml:"-"` } type metadataInputService4TestShapeSubStructure struct { SDKShapeTraits bool `type:"structure"` } type InputService5ProtocolTest struct { *service.Service } // New returns a new InputService5ProtocolTest client. func NewInputService5ProtocolTest(config *aws.Config) *InputService5ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice5protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService5ProtocolTest{service} } // newRequest creates a new request for a InputService5ProtocolTest operation and runs any // custom request initialization. func (c *InputService5ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService5TestCaseOperation1 = "OperationName" // InputService5TestCaseOperation1Request generates a request for the InputService5TestCaseOperation1 operation. func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputService5TestCaseOperation1Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService5TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService5TestShapeInputService5TestCaseOperation1Input{} } req = c.newRequest(op, input, output) output = &InputService5TestShapeInputService5TestCaseOperation1Output{} req.Data = output return } func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputService5TestCaseOperation1Input) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) { req, out := c.InputService5TestCaseOperation1Request(input) err := req.Send() return out, err } type InputService5TestShapeInputService5TestCaseOperation1Input struct { ListParam []*string `type:"list"` metadataInputService5TestShapeInputService5TestCaseOperation1Input `json:"-" xml:"-"` } type metadataInputService5TestShapeInputService5TestCaseOperation1Input struct { SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` } type InputService5TestShapeInputService5TestCaseOperation1Output struct { metadataInputService5TestShapeInputService5TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService5TestShapeInputService5TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService6ProtocolTest struct { *service.Service } // New returns a new InputService6ProtocolTest client. func NewInputService6ProtocolTest(config *aws.Config) *InputService6ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice6protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService6ProtocolTest{service} } // newRequest creates a new request for a InputService6ProtocolTest operation and runs any // custom request initialization. func (c *InputService6ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService6TestCaseOperation1 = "OperationName" // InputService6TestCaseOperation1Request generates a request for the InputService6TestCaseOperation1 operation. func (c *InputService6ProtocolTest) InputService6TestCaseOperation1Request(input *InputService6TestShapeInputService6TestCaseOperation1Input) (req *request.Request, output *InputService6TestShapeInputService6TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService6TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService6TestShapeInputService6TestCaseOperation1Input{} } req = c.newRequest(op, input, output) output = &InputService6TestShapeInputService6TestCaseOperation1Output{} req.Data = output return } func (c *InputService6ProtocolTest) InputService6TestCaseOperation1(input *InputService6TestShapeInputService6TestCaseOperation1Input) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) { req, out := c.InputService6TestCaseOperation1Request(input) err := req.Send() return out, err } type InputService6TestShapeInputService6TestCaseOperation1Input struct { ListParam []*string `locationName:"AlternateName" locationNameList:"NotMember" type:"list"` metadataInputService6TestShapeInputService6TestCaseOperation1Input `json:"-" xml:"-"` } type metadataInputService6TestShapeInputService6TestCaseOperation1Input struct { SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` } type InputService6TestShapeInputService6TestCaseOperation1Output struct { metadataInputService6TestShapeInputService6TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService6TestShapeInputService6TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService7ProtocolTest struct { *service.Service } // New returns a new InputService7ProtocolTest client. func NewInputService7ProtocolTest(config *aws.Config) *InputService7ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice7protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService7ProtocolTest{service} } // newRequest creates a new request for a InputService7ProtocolTest operation and runs any // custom request initialization. func (c *InputService7ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService7TestCaseOperation1 = "OperationName" // InputService7TestCaseOperation1Request generates a request for the InputService7TestCaseOperation1 operation. func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputService7TestCaseOperation1Input) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService7TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService7TestShapeInputService7TestCaseOperation1Input{} } req = c.newRequest(op, input, output) output = &InputService7TestShapeInputService7TestCaseOperation1Output{} req.Data = output return } func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputService7TestCaseOperation1Input) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) { req, out := c.InputService7TestCaseOperation1Request(input) err := req.Send() return out, err } type InputService7TestShapeInputService7TestCaseOperation1Input struct { ListParam []*string `type:"list" flattened:"true"` metadataInputService7TestShapeInputService7TestCaseOperation1Input `json:"-" xml:"-"` } type metadataInputService7TestShapeInputService7TestCaseOperation1Input struct { SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` } type InputService7TestShapeInputService7TestCaseOperation1Output struct { metadataInputService7TestShapeInputService7TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService7TestShapeInputService7TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService8ProtocolTest struct { *service.Service } // New returns a new InputService8ProtocolTest client. func NewInputService8ProtocolTest(config *aws.Config) *InputService8ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice8protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService8ProtocolTest{service} } // newRequest creates a new request for a InputService8ProtocolTest operation and runs any // custom request initialization. func (c *InputService8ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService8TestCaseOperation1 = "OperationName" // InputService8TestCaseOperation1Request generates a request for the InputService8TestCaseOperation1 operation. func (c *InputService8ProtocolTest) InputService8TestCaseOperation1Request(input *InputService8TestShapeInputService8TestCaseOperation1Input) (req *request.Request, output *InputService8TestShapeInputService8TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService8TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService8TestShapeInputService8TestCaseOperation1Input{} } req = c.newRequest(op, input, output) output = &InputService8TestShapeInputService8TestCaseOperation1Output{} req.Data = output return } func (c *InputService8ProtocolTest) InputService8TestCaseOperation1(input *InputService8TestShapeInputService8TestCaseOperation1Input) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) { req, out := c.InputService8TestCaseOperation1Request(input) err := req.Send() return out, err } type InputService8TestShapeInputService8TestCaseOperation1Input struct { ListParam []*string `locationName:"item" type:"list" flattened:"true"` metadataInputService8TestShapeInputService8TestCaseOperation1Input `json:"-" xml:"-"` } type metadataInputService8TestShapeInputService8TestCaseOperation1Input struct { SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` } type InputService8TestShapeInputService8TestCaseOperation1Output struct { metadataInputService8TestShapeInputService8TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService8TestShapeInputService8TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService9ProtocolTest struct { *service.Service } // New returns a new InputService9ProtocolTest client. func NewInputService9ProtocolTest(config *aws.Config) *InputService9ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice9protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService9ProtocolTest{service} } // newRequest creates a new request for a InputService9ProtocolTest operation and runs any // custom request initialization. func (c *InputService9ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService9TestCaseOperation1 = "OperationName" // InputService9TestCaseOperation1Request generates a request for the InputService9TestCaseOperation1 operation. func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input *InputService9TestShapeInputService9TestCaseOperation1Input) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService9TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService9TestShapeInputService9TestCaseOperation1Input{} } req = c.newRequest(op, input, output) output = &InputService9TestShapeInputService9TestCaseOperation1Output{} req.Data = output return } func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *InputService9TestShapeInputService9TestCaseOperation1Input) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) { req, out := c.InputService9TestCaseOperation1Request(input) err := req.Send() return out, err } type InputService9TestShapeInputService9TestCaseOperation1Input struct { ListParam []*InputService9TestShapeSingleFieldStruct `locationName:"item" type:"list" flattened:"true"` metadataInputService9TestShapeInputService9TestCaseOperation1Input `json:"-" xml:"-"` } type metadataInputService9TestShapeInputService9TestCaseOperation1Input struct { SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` } type InputService9TestShapeInputService9TestCaseOperation1Output struct { metadataInputService9TestShapeInputService9TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService9TestShapeInputService9TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService9TestShapeSingleFieldStruct struct { Element *string `locationName:"value" type:"string"` metadataInputService9TestShapeSingleFieldStruct `json:"-" xml:"-"` } type metadataInputService9TestShapeSingleFieldStruct struct { SDKShapeTraits bool `type:"structure"` } type InputService10ProtocolTest struct { *service.Service } // New returns a new InputService10ProtocolTest client. func NewInputService10ProtocolTest(config *aws.Config) *InputService10ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice10protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService10ProtocolTest{service} } // newRequest creates a new request for a InputService10ProtocolTest operation and runs any // custom request initialization. func (c *InputService10ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService10TestCaseOperation1 = "OperationName" // InputService10TestCaseOperation1Request generates a request for the InputService10TestCaseOperation1 operation. func (c *InputService10ProtocolTest) InputService10TestCaseOperation1Request(input *InputService10TestShapeInputService10TestCaseOperation1Input) (req *request.Request, output *InputService10TestShapeInputService10TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService10TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService10TestShapeInputService10TestCaseOperation1Input{} } req = c.newRequest(op, input, output) output = &InputService10TestShapeInputService10TestCaseOperation1Output{} req.Data = output return } func (c *InputService10ProtocolTest) InputService10TestCaseOperation1(input *InputService10TestShapeInputService10TestCaseOperation1Input) (*InputService10TestShapeInputService10TestCaseOperation1Output, error) { req, out := c.InputService10TestCaseOperation1Request(input) err := req.Send() return out, err } type InputService10TestShapeInputService10TestCaseOperation1Input struct { StructureParam *InputService10TestShapeStructureShape `type:"structure"` metadataInputService10TestShapeInputService10TestCaseOperation1Input `json:"-" xml:"-"` } type metadataInputService10TestShapeInputService10TestCaseOperation1Input struct { SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` } type InputService10TestShapeInputService10TestCaseOperation1Output struct { metadataInputService10TestShapeInputService10TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService10TestShapeInputService10TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService10TestShapeStructureShape struct { B []byte `locationName:"b" type:"blob"` T *time.Time `locationName:"t" type:"timestamp" timestampFormat:"iso8601"` metadataInputService10TestShapeStructureShape `json:"-" xml:"-"` } type metadataInputService10TestShapeStructureShape struct { SDKShapeTraits bool `type:"structure"` } type InputService11ProtocolTest struct { *service.Service } // New returns a new InputService11ProtocolTest client. func NewInputService11ProtocolTest(config *aws.Config) *InputService11ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice11protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService11ProtocolTest{service} } // newRequest creates a new request for a InputService11ProtocolTest operation and runs any // custom request initialization. func (c *InputService11ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService11TestCaseOperation1 = "OperationName" // InputService11TestCaseOperation1Request generates a request for the InputService11TestCaseOperation1 operation. func (c *InputService11ProtocolTest) InputService11TestCaseOperation1Request(input *InputService11TestShapeInputService11TestCaseOperation1Input) (req *request.Request, output *InputService11TestShapeInputService11TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService11TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService11TestShapeInputService11TestCaseOperation1Input{} } req = c.newRequest(op, input, output) output = &InputService11TestShapeInputService11TestCaseOperation1Output{} req.Data = output return } func (c *InputService11ProtocolTest) InputService11TestCaseOperation1(input *InputService11TestShapeInputService11TestCaseOperation1Input) (*InputService11TestShapeInputService11TestCaseOperation1Output, error) { req, out := c.InputService11TestCaseOperation1Request(input) err := req.Send() return out, err } type InputService11TestShapeInputService11TestCaseOperation1Input struct { Foo map[string]*string `location:"headers" locationName:"x-foo-" type:"map"` metadataInputService11TestShapeInputService11TestCaseOperation1Input `json:"-" xml:"-"` } type metadataInputService11TestShapeInputService11TestCaseOperation1Input struct { SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` } type InputService11TestShapeInputService11TestCaseOperation1Output struct { metadataInputService11TestShapeInputService11TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService11TestShapeInputService11TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService12ProtocolTest struct { *service.Service } // New returns a new InputService12ProtocolTest client. func NewInputService12ProtocolTest(config *aws.Config) *InputService12ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice12protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService12ProtocolTest{service} } // newRequest creates a new request for a InputService12ProtocolTest operation and runs any // custom request initialization. func (c *InputService12ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService12TestCaseOperation1 = "OperationName" // InputService12TestCaseOperation1Request generates a request for the InputService12TestCaseOperation1 operation. func (c *InputService12ProtocolTest) InputService12TestCaseOperation1Request(input *InputService12TestShapeInputService12TestCaseOperation1Input) (req *request.Request, output *InputService12TestShapeInputService12TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService12TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService12TestShapeInputService12TestCaseOperation1Input{} } req = c.newRequest(op, input, output) output = &InputService12TestShapeInputService12TestCaseOperation1Output{} req.Data = output return } func (c *InputService12ProtocolTest) InputService12TestCaseOperation1(input *InputService12TestShapeInputService12TestCaseOperation1Input) (*InputService12TestShapeInputService12TestCaseOperation1Output, error) { req, out := c.InputService12TestCaseOperation1Request(input) err := req.Send() return out, err } type InputService12TestShapeInputService12TestCaseOperation1Input struct { Foo *string `locationName:"foo" type:"string"` metadataInputService12TestShapeInputService12TestCaseOperation1Input `json:"-" xml:"-"` } type metadataInputService12TestShapeInputService12TestCaseOperation1Input struct { SDKShapeTraits bool `type:"structure" payload:"Foo"` } type InputService12TestShapeInputService12TestCaseOperation1Output struct { metadataInputService12TestShapeInputService12TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService12TestShapeInputService12TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService13ProtocolTest struct { *service.Service } // New returns a new InputService13ProtocolTest client. func NewInputService13ProtocolTest(config *aws.Config) *InputService13ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice13protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService13ProtocolTest{service} } // newRequest creates a new request for a InputService13ProtocolTest operation and runs any // custom request initialization. func (c *InputService13ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService13TestCaseOperation1 = "OperationName" // InputService13TestCaseOperation1Request generates a request for the InputService13TestCaseOperation1 operation. func (c *InputService13ProtocolTest) InputService13TestCaseOperation1Request(input *InputService13TestShapeInputShape) (req *request.Request, output *InputService13TestShapeInputService13TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService13TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService13TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService13TestShapeInputService13TestCaseOperation1Output{} req.Data = output return } func (c *InputService13ProtocolTest) InputService13TestCaseOperation1(input *InputService13TestShapeInputShape) (*InputService13TestShapeInputService13TestCaseOperation1Output, error) { req, out := c.InputService13TestCaseOperation1Request(input) err := req.Send() return out, err } const opInputService13TestCaseOperation2 = "OperationName" // InputService13TestCaseOperation2Request generates a request for the InputService13TestCaseOperation2 operation. func (c *InputService13ProtocolTest) InputService13TestCaseOperation2Request(input *InputService13TestShapeInputShape) (req *request.Request, output *InputService13TestShapeInputService13TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService13TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService13TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService13TestShapeInputService13TestCaseOperation2Output{} req.Data = output return } func (c *InputService13ProtocolTest) InputService13TestCaseOperation2(input *InputService13TestShapeInputShape) (*InputService13TestShapeInputService13TestCaseOperation2Output, error) { req, out := c.InputService13TestCaseOperation2Request(input) err := req.Send() return out, err } type InputService13TestShapeInputService13TestCaseOperation1Output struct { metadataInputService13TestShapeInputService13TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService13TestShapeInputService13TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService13TestShapeInputService13TestCaseOperation2Output struct { metadataInputService13TestShapeInputService13TestCaseOperation2Output `json:"-" xml:"-"` } type metadataInputService13TestShapeInputService13TestCaseOperation2Output struct { SDKShapeTraits bool `type:"structure"` } type InputService13TestShapeInputShape struct { Foo []byte `locationName:"foo" type:"blob"` metadataInputService13TestShapeInputShape `json:"-" xml:"-"` } type metadataInputService13TestShapeInputShape struct { SDKShapeTraits bool `type:"structure" payload:"Foo"` } type InputService14ProtocolTest struct { *service.Service } // New returns a new InputService14ProtocolTest client. func NewInputService14ProtocolTest(config *aws.Config) *InputService14ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice14protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService14ProtocolTest{service} } // newRequest creates a new request for a InputService14ProtocolTest operation and runs any // custom request initialization. func (c *InputService14ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService14TestCaseOperation1 = "OperationName" // InputService14TestCaseOperation1Request generates a request for the InputService14TestCaseOperation1 operation. func (c *InputService14ProtocolTest) InputService14TestCaseOperation1Request(input *InputService14TestShapeInputShape) (req *request.Request, output *InputService14TestShapeInputService14TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService14TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService14TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService14TestShapeInputService14TestCaseOperation1Output{} req.Data = output return } func (c *InputService14ProtocolTest) InputService14TestCaseOperation1(input *InputService14TestShapeInputShape) (*InputService14TestShapeInputService14TestCaseOperation1Output, error) { req, out := c.InputService14TestCaseOperation1Request(input) err := req.Send() return out, err } const opInputService14TestCaseOperation2 = "OperationName" // InputService14TestCaseOperation2Request generates a request for the InputService14TestCaseOperation2 operation. func (c *InputService14ProtocolTest) InputService14TestCaseOperation2Request(input *InputService14TestShapeInputShape) (req *request.Request, output *InputService14TestShapeInputService14TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService14TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService14TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService14TestShapeInputService14TestCaseOperation2Output{} req.Data = output return } func (c *InputService14ProtocolTest) InputService14TestCaseOperation2(input *InputService14TestShapeInputShape) (*InputService14TestShapeInputService14TestCaseOperation2Output, error) { req, out := c.InputService14TestCaseOperation2Request(input) err := req.Send() return out, err } const opInputService14TestCaseOperation3 = "OperationName" // InputService14TestCaseOperation3Request generates a request for the InputService14TestCaseOperation3 operation. func (c *InputService14ProtocolTest) InputService14TestCaseOperation3Request(input *InputService14TestShapeInputShape) (req *request.Request, output *InputService14TestShapeInputService14TestCaseOperation3Output) { op := &request.Operation{ Name: opInputService14TestCaseOperation3, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService14TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService14TestShapeInputService14TestCaseOperation3Output{} req.Data = output return } func (c *InputService14ProtocolTest) InputService14TestCaseOperation3(input *InputService14TestShapeInputShape) (*InputService14TestShapeInputService14TestCaseOperation3Output, error) { req, out := c.InputService14TestCaseOperation3Request(input) err := req.Send() return out, err } type InputService14TestShapeFooShape struct { Baz *string `locationName:"baz" type:"string"` metadataInputService14TestShapeFooShape `json:"-" xml:"-"` } type metadataInputService14TestShapeFooShape struct { SDKShapeTraits bool `locationName:"foo" type:"structure"` } type InputService14TestShapeInputService14TestCaseOperation1Output struct { metadataInputService14TestShapeInputService14TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService14TestShapeInputService14TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService14TestShapeInputService14TestCaseOperation2Output struct { metadataInputService14TestShapeInputService14TestCaseOperation2Output `json:"-" xml:"-"` } type metadataInputService14TestShapeInputService14TestCaseOperation2Output struct { SDKShapeTraits bool `type:"structure"` } type InputService14TestShapeInputService14TestCaseOperation3Output struct { metadataInputService14TestShapeInputService14TestCaseOperation3Output `json:"-" xml:"-"` } type metadataInputService14TestShapeInputService14TestCaseOperation3Output struct { SDKShapeTraits bool `type:"structure"` } type InputService14TestShapeInputShape struct { Foo *InputService14TestShapeFooShape `locationName:"foo" type:"structure"` metadataInputService14TestShapeInputShape `json:"-" xml:"-"` } type metadataInputService14TestShapeInputShape struct { SDKShapeTraits bool `type:"structure" payload:"Foo"` } type InputService15ProtocolTest struct { *service.Service } // New returns a new InputService15ProtocolTest client. func NewInputService15ProtocolTest(config *aws.Config) *InputService15ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice15protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService15ProtocolTest{service} } // newRequest creates a new request for a InputService15ProtocolTest operation and runs any // custom request initialization. func (c *InputService15ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService15TestCaseOperation1 = "OperationName" // InputService15TestCaseOperation1Request generates a request for the InputService15TestCaseOperation1 operation. func (c *InputService15ProtocolTest) InputService15TestCaseOperation1Request(input *InputService15TestShapeInputService15TestCaseOperation1Input) (req *request.Request, output *InputService15TestShapeInputService15TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService15TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService15TestShapeInputService15TestCaseOperation1Input{} } req = c.newRequest(op, input, output) output = &InputService15TestShapeInputService15TestCaseOperation1Output{} req.Data = output return } func (c *InputService15ProtocolTest) InputService15TestCaseOperation1(input *InputService15TestShapeInputService15TestCaseOperation1Input) (*InputService15TestShapeInputService15TestCaseOperation1Output, error) { req, out := c.InputService15TestCaseOperation1Request(input) err := req.Send() return out, err } type InputService15TestShapeGrant struct { Grantee *InputService15TestShapeGrantee `type:"structure"` metadataInputService15TestShapeGrant `json:"-" xml:"-"` } type metadataInputService15TestShapeGrant struct { SDKShapeTraits bool `locationName:"Grant" type:"structure"` } type InputService15TestShapeGrantee struct { EmailAddress *string `type:"string"` Type *string `locationName:"xsi:type" type:"string" xmlAttribute:"true"` metadataInputService15TestShapeGrantee `json:"-" xml:"-"` } type metadataInputService15TestShapeGrantee struct { SDKShapeTraits bool `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"` } type InputService15TestShapeInputService15TestCaseOperation1Input struct { Grant *InputService15TestShapeGrant `locationName:"Grant" type:"structure"` metadataInputService15TestShapeInputService15TestCaseOperation1Input `json:"-" xml:"-"` } type metadataInputService15TestShapeInputService15TestCaseOperation1Input struct { SDKShapeTraits bool `type:"structure" payload:"Grant"` } type InputService15TestShapeInputService15TestCaseOperation1Output struct { metadataInputService15TestShapeInputService15TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService15TestShapeInputService15TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService16ProtocolTest struct { *service.Service } // New returns a new InputService16ProtocolTest client. func NewInputService16ProtocolTest(config *aws.Config) *InputService16ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice16protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService16ProtocolTest{service} } // newRequest creates a new request for a InputService16ProtocolTest operation and runs any // custom request initialization. func (c *InputService16ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService16TestCaseOperation1 = "OperationName" // InputService16TestCaseOperation1Request generates a request for the InputService16TestCaseOperation1 operation. func (c *InputService16ProtocolTest) InputService16TestCaseOperation1Request(input *InputService16TestShapeInputService16TestCaseOperation1Input) (req *request.Request, output *InputService16TestShapeInputService16TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService16TestCaseOperation1, HTTPMethod: "GET", HTTPPath: "/{Bucket}/{Key+}", } if input == nil { input = &InputService16TestShapeInputService16TestCaseOperation1Input{} } req = c.newRequest(op, input, output) output = &InputService16TestShapeInputService16TestCaseOperation1Output{} req.Data = output return } func (c *InputService16ProtocolTest) InputService16TestCaseOperation1(input *InputService16TestShapeInputService16TestCaseOperation1Input) (*InputService16TestShapeInputService16TestCaseOperation1Output, error) { req, out := c.InputService16TestCaseOperation1Request(input) err := req.Send() return out, err } type InputService16TestShapeInputService16TestCaseOperation1Input struct { Bucket *string `location:"uri" type:"string"` Key *string `location:"uri" type:"string"` metadataInputService16TestShapeInputService16TestCaseOperation1Input `json:"-" xml:"-"` } type metadataInputService16TestShapeInputService16TestCaseOperation1Input struct { SDKShapeTraits bool `type:"structure"` } type InputService16TestShapeInputService16TestCaseOperation1Output struct { metadataInputService16TestShapeInputService16TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService16TestShapeInputService16TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService17ProtocolTest struct { *service.Service } // New returns a new InputService17ProtocolTest client. func NewInputService17ProtocolTest(config *aws.Config) *InputService17ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice17protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService17ProtocolTest{service} } // newRequest creates a new request for a InputService17ProtocolTest operation and runs any // custom request initialization. func (c *InputService17ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService17TestCaseOperation1 = "OperationName" // InputService17TestCaseOperation1Request generates a request for the InputService17TestCaseOperation1 operation. func (c *InputService17ProtocolTest) InputService17TestCaseOperation1Request(input *InputService17TestShapeInputShape) (req *request.Request, output *InputService17TestShapeInputService17TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService17TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService17TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService17TestShapeInputService17TestCaseOperation1Output{} req.Data = output return } func (c *InputService17ProtocolTest) InputService17TestCaseOperation1(input *InputService17TestShapeInputShape) (*InputService17TestShapeInputService17TestCaseOperation1Output, error) { req, out := c.InputService17TestCaseOperation1Request(input) err := req.Send() return out, err } const opInputService17TestCaseOperation2 = "OperationName" // InputService17TestCaseOperation2Request generates a request for the InputService17TestCaseOperation2 operation. func (c *InputService17ProtocolTest) InputService17TestCaseOperation2Request(input *InputService17TestShapeInputShape) (req *request.Request, output *InputService17TestShapeInputService17TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService17TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/path?abc=mno", } if input == nil { input = &InputService17TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService17TestShapeInputService17TestCaseOperation2Output{} req.Data = output return } func (c *InputService17ProtocolTest) InputService17TestCaseOperation2(input *InputService17TestShapeInputShape) (*InputService17TestShapeInputService17TestCaseOperation2Output, error) { req, out := c.InputService17TestCaseOperation2Request(input) err := req.Send() return out, err } type InputService17TestShapeInputService17TestCaseOperation1Output struct { metadataInputService17TestShapeInputService17TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService17TestShapeInputService17TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService17TestShapeInputService17TestCaseOperation2Output struct { metadataInputService17TestShapeInputService17TestCaseOperation2Output `json:"-" xml:"-"` } type metadataInputService17TestShapeInputService17TestCaseOperation2Output struct { SDKShapeTraits bool `type:"structure"` } type InputService17TestShapeInputShape struct { Foo *string `location:"querystring" locationName:"param-name" type:"string"` metadataInputService17TestShapeInputShape `json:"-" xml:"-"` } type metadataInputService17TestShapeInputShape struct { SDKShapeTraits bool `type:"structure"` } type InputService18ProtocolTest struct { *service.Service } // New returns a new InputService18ProtocolTest client. func NewInputService18ProtocolTest(config *aws.Config) *InputService18ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice18protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService18ProtocolTest{service} } // newRequest creates a new request for a InputService18ProtocolTest operation and runs any // custom request initialization. func (c *InputService18ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService18TestCaseOperation1 = "OperationName" // InputService18TestCaseOperation1Request generates a request for the InputService18TestCaseOperation1 operation. func (c *InputService18ProtocolTest) InputService18TestCaseOperation1Request(input *InputService18TestShapeInputShape) (req *request.Request, output *InputService18TestShapeInputService18TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService18TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService18TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService18TestShapeInputService18TestCaseOperation1Output{} req.Data = output return } func (c *InputService18ProtocolTest) InputService18TestCaseOperation1(input *InputService18TestShapeInputShape) (*InputService18TestShapeInputService18TestCaseOperation1Output, error) { req, out := c.InputService18TestCaseOperation1Request(input) err := req.Send() return out, err } const opInputService18TestCaseOperation2 = "OperationName" // InputService18TestCaseOperation2Request generates a request for the InputService18TestCaseOperation2 operation. func (c *InputService18ProtocolTest) InputService18TestCaseOperation2Request(input *InputService18TestShapeInputShape) (req *request.Request, output *InputService18TestShapeInputService18TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService18TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService18TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService18TestShapeInputService18TestCaseOperation2Output{} req.Data = output return } func (c *InputService18ProtocolTest) InputService18TestCaseOperation2(input *InputService18TestShapeInputShape) (*InputService18TestShapeInputService18TestCaseOperation2Output, error) { req, out := c.InputService18TestCaseOperation2Request(input) err := req.Send() return out, err } const opInputService18TestCaseOperation3 = "OperationName" // InputService18TestCaseOperation3Request generates a request for the InputService18TestCaseOperation3 operation. func (c *InputService18ProtocolTest) InputService18TestCaseOperation3Request(input *InputService18TestShapeInputShape) (req *request.Request, output *InputService18TestShapeInputService18TestCaseOperation3Output) { op := &request.Operation{ Name: opInputService18TestCaseOperation3, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService18TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService18TestShapeInputService18TestCaseOperation3Output{} req.Data = output return } func (c *InputService18ProtocolTest) InputService18TestCaseOperation3(input *InputService18TestShapeInputShape) (*InputService18TestShapeInputService18TestCaseOperation3Output, error) { req, out := c.InputService18TestCaseOperation3Request(input) err := req.Send() return out, err } const opInputService18TestCaseOperation4 = "OperationName" // InputService18TestCaseOperation4Request generates a request for the InputService18TestCaseOperation4 operation. func (c *InputService18ProtocolTest) InputService18TestCaseOperation4Request(input *InputService18TestShapeInputShape) (req *request.Request, output *InputService18TestShapeInputService18TestCaseOperation4Output) { op := &request.Operation{ Name: opInputService18TestCaseOperation4, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService18TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService18TestShapeInputService18TestCaseOperation4Output{} req.Data = output return } func (c *InputService18ProtocolTest) InputService18TestCaseOperation4(input *InputService18TestShapeInputShape) (*InputService18TestShapeInputService18TestCaseOperation4Output, error) { req, out := c.InputService18TestCaseOperation4Request(input) err := req.Send() return out, err } const opInputService18TestCaseOperation5 = "OperationName" // InputService18TestCaseOperation5Request generates a request for the InputService18TestCaseOperation5 operation. func (c *InputService18ProtocolTest) InputService18TestCaseOperation5Request(input *InputService18TestShapeInputShape) (req *request.Request, output *InputService18TestShapeInputService18TestCaseOperation5Output) { op := &request.Operation{ Name: opInputService18TestCaseOperation5, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService18TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService18TestShapeInputService18TestCaseOperation5Output{} req.Data = output return } func (c *InputService18ProtocolTest) InputService18TestCaseOperation5(input *InputService18TestShapeInputShape) (*InputService18TestShapeInputService18TestCaseOperation5Output, error) { req, out := c.InputService18TestCaseOperation5Request(input) err := req.Send() return out, err } const opInputService18TestCaseOperation6 = "OperationName" // InputService18TestCaseOperation6Request generates a request for the InputService18TestCaseOperation6 operation. func (c *InputService18ProtocolTest) InputService18TestCaseOperation6Request(input *InputService18TestShapeInputShape) (req *request.Request, output *InputService18TestShapeInputService18TestCaseOperation6Output) { op := &request.Operation{ Name: opInputService18TestCaseOperation6, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService18TestShapeInputShape{} } req = c.newRequest(op, input, output) output = &InputService18TestShapeInputService18TestCaseOperation6Output{} req.Data = output return } func (c *InputService18ProtocolTest) InputService18TestCaseOperation6(input *InputService18TestShapeInputShape) (*InputService18TestShapeInputService18TestCaseOperation6Output, error) { req, out := c.InputService18TestCaseOperation6Request(input) err := req.Send() return out, err } type InputService18TestShapeInputService18TestCaseOperation1Output struct { metadataInputService18TestShapeInputService18TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService18TestShapeInputService18TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } type InputService18TestShapeInputService18TestCaseOperation2Output struct { metadataInputService18TestShapeInputService18TestCaseOperation2Output `json:"-" xml:"-"` } type metadataInputService18TestShapeInputService18TestCaseOperation2Output struct { SDKShapeTraits bool `type:"structure"` } type InputService18TestShapeInputService18TestCaseOperation3Output struct { metadataInputService18TestShapeInputService18TestCaseOperation3Output `json:"-" xml:"-"` } type metadataInputService18TestShapeInputService18TestCaseOperation3Output struct { SDKShapeTraits bool `type:"structure"` } type InputService18TestShapeInputService18TestCaseOperation4Output struct { metadataInputService18TestShapeInputService18TestCaseOperation4Output `json:"-" xml:"-"` } type metadataInputService18TestShapeInputService18TestCaseOperation4Output struct { SDKShapeTraits bool `type:"structure"` } type InputService18TestShapeInputService18TestCaseOperation5Output struct { metadataInputService18TestShapeInputService18TestCaseOperation5Output `json:"-" xml:"-"` } type metadataInputService18TestShapeInputService18TestCaseOperation5Output struct { SDKShapeTraits bool `type:"structure"` } type InputService18TestShapeInputService18TestCaseOperation6Output struct { metadataInputService18TestShapeInputService18TestCaseOperation6Output `json:"-" xml:"-"` } type metadataInputService18TestShapeInputService18TestCaseOperation6Output struct { SDKShapeTraits bool `type:"structure"` } type InputService18TestShapeInputShape struct { RecursiveStruct *InputService18TestShapeRecursiveStructType `type:"structure"` metadataInputService18TestShapeInputShape `json:"-" xml:"-"` } type metadataInputService18TestShapeInputShape struct { SDKShapeTraits bool `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` } type InputService18TestShapeRecursiveStructType struct { NoRecurse *string `type:"string"` RecursiveList []*InputService18TestShapeRecursiveStructType `type:"list"` RecursiveMap map[string]*InputService18TestShapeRecursiveStructType `type:"map"` RecursiveStruct *InputService18TestShapeRecursiveStructType `type:"structure"` metadataInputService18TestShapeRecursiveStructType `json:"-" xml:"-"` } type metadataInputService18TestShapeRecursiveStructType struct { SDKShapeTraits bool `type:"structure"` } type InputService19ProtocolTest struct { *service.Service } // New returns a new InputService19ProtocolTest client. func NewInputService19ProtocolTest(config *aws.Config) *InputService19ProtocolTest { service := &service.Service{ ServiceInfo: serviceinfo.ServiceInfo{ Config: defaults.DefaultConfig.Merge(config), ServiceName: "inputservice19protocoltest", APIVersion: "2014-01-01", }, } service.Initialize() // Handlers service.Handlers.Sign.PushBack(v4.Sign) service.Handlers.Build.PushBack(restxml.Build) service.Handlers.Unmarshal.PushBack(restxml.Unmarshal) service.Handlers.UnmarshalMeta.PushBack(restxml.UnmarshalMeta) service.Handlers.UnmarshalError.PushBack(restxml.UnmarshalError) return &InputService19ProtocolTest{service} } // newRequest creates a new request for a InputService19ProtocolTest operation and runs any // custom request initialization. func (c *InputService19ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { req := c.NewRequest(op, params, data) return req } const opInputService19TestCaseOperation1 = "OperationName" // InputService19TestCaseOperation1Request generates a request for the InputService19TestCaseOperation1 operation. func (c *InputService19ProtocolTest) InputService19TestCaseOperation1Request(input *InputService19TestShapeInputService19TestCaseOperation1Input) (req *request.Request, output *InputService19TestShapeInputService19TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService19TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService19TestShapeInputService19TestCaseOperation1Input{} } req = c.newRequest(op, input, output) output = &InputService19TestShapeInputService19TestCaseOperation1Output{} req.Data = output return } func (c *InputService19ProtocolTest) InputService19TestCaseOperation1(input *InputService19TestShapeInputService19TestCaseOperation1Input) (*InputService19TestShapeInputService19TestCaseOperation1Output, error) { req, out := c.InputService19TestCaseOperation1Request(input) err := req.Send() return out, err } type InputService19TestShapeInputService19TestCaseOperation1Input struct { TimeArgInHeader *time.Time `location:"header" locationName:"x-amz-timearg" type:"timestamp" timestampFormat:"rfc822"` metadataInputService19TestShapeInputService19TestCaseOperation1Input `json:"-" xml:"-"` } type metadataInputService19TestShapeInputService19TestCaseOperation1Input struct { SDKShapeTraits bool `type:"structure"` } type InputService19TestShapeInputService19TestCaseOperation1Output struct { metadataInputService19TestShapeInputService19TestCaseOperation1Output `json:"-" xml:"-"` } type metadataInputService19TestShapeInputService19TestCaseOperation1Output struct { SDKShapeTraits bool `type:"structure"` } // // Tests begin here // func TestInputService1ProtocolTestBasicXMLSerializationCase1(t *testing.T) { svc := NewInputService1ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService1TestShapeInputShape{ Description: aws.String("bar"), Name: aws.String("foo"), } req, _ := svc.InputService1TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`barfoo`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String()) // assert headers } func TestInputService1ProtocolTestBasicXMLSerializationCase2(t *testing.T) { svc := NewInputService1ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService1TestShapeInputShape{ Description: aws.String("bar"), Name: aws.String("foo"), } req, _ := svc.InputService1TestCaseOperation2Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`barfoo`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String()) // assert headers } func TestInputService2ProtocolTestSerializeOtherScalarTypesCase1(t *testing.T) { svc := NewInputService2ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService2TestShapeInputService2TestCaseOperation1Input{ First: aws.Bool(true), Fourth: aws.Int64(3), Second: aws.Bool(false), Third: aws.Float64(1.2), } req, _ := svc.InputService2TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`true3false1.2`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String()) // assert headers } func TestInputService3ProtocolTestNestedStructuresCase1(t *testing.T) { svc := NewInputService3ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService3TestShapeInputService3TestCaseOperation1Input{ Description: aws.String("baz"), SubStructure: &InputService3TestShapeSubStructure{ Bar: aws.String("b"), Foo: aws.String("a"), }, } req, _ := svc.InputService3TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`bazba`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String()) // assert headers } func TestInputService4ProtocolTestNestedStructuresCase1(t *testing.T) { svc := NewInputService4ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService4TestShapeInputService4TestCaseOperation1Input{ Description: aws.String("baz"), SubStructure: &InputService4TestShapeSubStructure{}, } req, _ := svc.InputService4TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`baz`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String()) // assert headers } func TestInputService5ProtocolTestNonFlattenedListsCase1(t *testing.T) { svc := NewInputService5ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService5TestShapeInputService5TestCaseOperation1Input{ ListParam: []*string{ aws.String("one"), aws.String("two"), aws.String("three"), }, } req, _ := svc.InputService5TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`onetwothree`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String()) // assert headers } func TestInputService6ProtocolTestNonFlattenedListsWithLocationNameCase1(t *testing.T) { svc := NewInputService6ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService6TestShapeInputService6TestCaseOperation1Input{ ListParam: []*string{ aws.String("one"), aws.String("two"), aws.String("three"), }, } req, _ := svc.InputService6TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`onetwothree`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String()) // assert headers } func TestInputService7ProtocolTestFlattenedListsCase1(t *testing.T) { svc := NewInputService7ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService7TestShapeInputService7TestCaseOperation1Input{ ListParam: []*string{ aws.String("one"), aws.String("two"), aws.String("three"), }, } req, _ := svc.InputService7TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`onetwothree`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String()) // assert headers } func TestInputService8ProtocolTestFlattenedListsWithLocationNameCase1(t *testing.T) { svc := NewInputService8ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService8TestShapeInputService8TestCaseOperation1Input{ ListParam: []*string{ aws.String("one"), aws.String("two"), aws.String("three"), }, } req, _ := svc.InputService8TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`onetwothree`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String()) // assert headers } func TestInputService9ProtocolTestListOfStructuresCase1(t *testing.T) { svc := NewInputService9ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService9TestShapeInputService9TestCaseOperation1Input{ ListParam: []*InputService9TestShapeSingleFieldStruct{ { Element: aws.String("one"), }, { Element: aws.String("two"), }, { Element: aws.String("three"), }, }, } req, _ := svc.InputService9TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`onetwothree`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String()) // assert headers } func TestInputService10ProtocolTestBlobAndTimestampShapesCase1(t *testing.T) { svc := NewInputService10ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService10TestShapeInputService10TestCaseOperation1Input{ StructureParam: &InputService10TestShapeStructureShape{ B: []byte("foo"), T: aws.Time(time.Unix(1422172800, 0)), }, } req, _ := svc.InputService10TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`Zm9v2015-01-25T08:00:00Z`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/2014-01-01/hostedzone", r.URL.String()) // assert headers } func TestInputService11ProtocolTestHeaderMapsCase1(t *testing.T) { svc := NewInputService11ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService11TestShapeInputService11TestCaseOperation1Input{ Foo: map[string]*string{ "a": aws.String("b"), "c": aws.String("d"), }, } req, _ := svc.InputService11TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert URL assert.Equal(t, "https://test/", r.URL.String()) // assert headers assert.Equal(t, "b", r.Header.Get("x-foo-a")) assert.Equal(t, "d", r.Header.Get("x-foo-c")) } func TestInputService12ProtocolTestStringPayloadCase1(t *testing.T) { svc := NewInputService12ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService12TestShapeInputService12TestCaseOperation1Input{ Foo: aws.String("bar"), } req, _ := svc.InputService12TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`bar`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/", r.URL.String()) // assert headers } func TestInputService13ProtocolTestBlobPayloadCase1(t *testing.T) { svc := NewInputService13ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService13TestShapeInputShape{ Foo: []byte("bar"), } req, _ := svc.InputService13TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`bar`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/", r.URL.String()) // assert headers } func TestInputService13ProtocolTestBlobPayloadCase2(t *testing.T) { svc := NewInputService13ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService13TestShapeInputShape{} req, _ := svc.InputService13TestCaseOperation2Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert URL assert.Equal(t, "https://test/", r.URL.String()) // assert headers } func TestInputService14ProtocolTestStructurePayloadCase1(t *testing.T) { svc := NewInputService14ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService14TestShapeInputShape{ Foo: &InputService14TestShapeFooShape{ Baz: aws.String("bar"), }, } req, _ := svc.InputService14TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`bar`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/", r.URL.String()) // assert headers } func TestInputService14ProtocolTestStructurePayloadCase2(t *testing.T) { svc := NewInputService14ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService14TestShapeInputShape{ Foo: &InputService14TestShapeFooShape{}, } req, _ := svc.InputService14TestCaseOperation2Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(``), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/", r.URL.String()) // assert headers } func TestInputService14ProtocolTestStructurePayloadCase3(t *testing.T) { svc := NewInputService14ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService14TestShapeInputShape{} req, _ := svc.InputService14TestCaseOperation3Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert URL assert.Equal(t, "https://test/", r.URL.String()) // assert headers } func TestInputService15ProtocolTestXMLAttributeCase1(t *testing.T) { svc := NewInputService15ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService15TestShapeInputService15TestCaseOperation1Input{ Grant: &InputService15TestShapeGrant{ Grantee: &InputService15TestShapeGrantee{ EmailAddress: aws.String("foo@example.com"), Type: aws.String("CanonicalUser"), }, }, } req, _ := svc.InputService15TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`foo@example.com`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/", r.URL.String()) // assert headers } func TestInputService16ProtocolTestGreedyKeysCase1(t *testing.T) { svc := NewInputService16ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService16TestShapeInputService16TestCaseOperation1Input{ Bucket: aws.String("my/bucket"), Key: aws.String("testing /123"), } req, _ := svc.InputService16TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert URL assert.Equal(t, "https://test/my%2Fbucket/testing%20/123", r.URL.String()) // assert headers } func TestInputService17ProtocolTestOmitsNullQueryParamsButSerializesEmptyStringsCase1(t *testing.T) { svc := NewInputService17ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService17TestShapeInputShape{} req, _ := svc.InputService17TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert URL assert.Equal(t, "https://test/path", r.URL.String()) // assert headers } func TestInputService17ProtocolTestOmitsNullQueryParamsButSerializesEmptyStringsCase2(t *testing.T) { svc := NewInputService17ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService17TestShapeInputShape{ Foo: aws.String(""), } req, _ := svc.InputService17TestCaseOperation2Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert URL assert.Equal(t, "https://test/path?abc=mno¶m-name=", r.URL.String()) // assert headers } func TestInputService18ProtocolTestRecursiveShapesCase1(t *testing.T) { svc := NewInputService18ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService18TestShapeInputShape{ RecursiveStruct: &InputService18TestShapeRecursiveStructType{ NoRecurse: aws.String("foo"), }, } req, _ := svc.InputService18TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`foo`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/path", r.URL.String()) // assert headers } func TestInputService18ProtocolTestRecursiveShapesCase2(t *testing.T) { svc := NewInputService18ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService18TestShapeInputShape{ RecursiveStruct: &InputService18TestShapeRecursiveStructType{ RecursiveStruct: &InputService18TestShapeRecursiveStructType{ NoRecurse: aws.String("foo"), }, }, } req, _ := svc.InputService18TestCaseOperation2Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`foo`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/path", r.URL.String()) // assert headers } func TestInputService18ProtocolTestRecursiveShapesCase3(t *testing.T) { svc := NewInputService18ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService18TestShapeInputShape{ RecursiveStruct: &InputService18TestShapeRecursiveStructType{ RecursiveStruct: &InputService18TestShapeRecursiveStructType{ RecursiveStruct: &InputService18TestShapeRecursiveStructType{ RecursiveStruct: &InputService18TestShapeRecursiveStructType{ NoRecurse: aws.String("foo"), }, }, }, }, } req, _ := svc.InputService18TestCaseOperation3Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`foo`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/path", r.URL.String()) // assert headers } func TestInputService18ProtocolTestRecursiveShapesCase4(t *testing.T) { svc := NewInputService18ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService18TestShapeInputShape{ RecursiveStruct: &InputService18TestShapeRecursiveStructType{ RecursiveList: []*InputService18TestShapeRecursiveStructType{ { NoRecurse: aws.String("foo"), }, { NoRecurse: aws.String("bar"), }, }, }, } req, _ := svc.InputService18TestCaseOperation4Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`foobar`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/path", r.URL.String()) // assert headers } func TestInputService18ProtocolTestRecursiveShapesCase5(t *testing.T) { svc := NewInputService18ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService18TestShapeInputShape{ RecursiveStruct: &InputService18TestShapeRecursiveStructType{ RecursiveList: []*InputService18TestShapeRecursiveStructType{ { NoRecurse: aws.String("foo"), }, { RecursiveStruct: &InputService18TestShapeRecursiveStructType{ NoRecurse: aws.String("bar"), }, }, }, }, } req, _ := svc.InputService18TestCaseOperation5Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`foobar`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/path", r.URL.String()) // assert headers } func TestInputService18ProtocolTestRecursiveShapesCase6(t *testing.T) { svc := NewInputService18ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService18TestShapeInputShape{ RecursiveStruct: &InputService18TestShapeRecursiveStructType{ RecursiveMap: map[string]*InputService18TestShapeRecursiveStructType{ "bar": { NoRecurse: aws.String("bar"), }, "foo": { NoRecurse: aws.String("foo"), }, }, }, } req, _ := svc.InputService18TestCaseOperation6Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert body assert.NotNil(t, r.Body) body := util.SortXML(r.Body) assert.Equal(t, util.Trim(`barbarfoofoo`), util.Trim(string(body))) // assert URL assert.Equal(t, "https://test/path", r.URL.String()) // assert headers } func TestInputService19ProtocolTestTimestampInHeaderCase1(t *testing.T) { svc := NewInputService19ProtocolTest(nil) svc.Endpoint = "https://test" input := &InputService19TestShapeInputService19TestCaseOperation1Input{ TimeArgInHeader: aws.Time(time.Unix(1422172800, 0)), } req, _ := svc.InputService19TestCaseOperation1Request(input) r := req.HTTPRequest // build request restxml.Build(req) assert.NoError(t, req.Error) // assert URL assert.Equal(t, "https://test/path", r.URL.String()) // assert headers assert.Equal(t, "Sun, 25 Jan 2015 08:00:00 GMT", r.Header.Get("x-amz-timearg")) }