package restxml_test
import (
"github.com/awslabs/aws-sdk-go/aws"
"github.com/awslabs/aws-sdk-go/internal/protocol/restxml"
"github.com/awslabs/aws-sdk-go/internal/signer/v4"
"bytes"
"encoding/json"
"encoding/xml"
"github.com/awslabs/aws-sdk-go/internal/protocol/xml/xmlutil"
"github.com/awslabs/aws-sdk-go/internal/util"
"github.com/stretchr/testify/assert"
"io/ioutil"
"net/http"
"net/url"
"testing"
"time"
)
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{}
// OutputService1ProtocolTest is a client for OutputService1ProtocolTest.
type OutputService1ProtocolTest struct {
*aws.Service
}
// New returns a new OutputService1ProtocolTest client.
func NewOutputService1ProtocolTest(config *aws.Config) *OutputService1ProtocolTest {
if config == nil {
config = &aws.Config{}
}
service := &aws.Service{
Config: aws.DefaultConfig.Merge(config),
ServiceName: "outputservice1protocoltest",
APIVersion: "",
}
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 &OutputService1ProtocolTest{service}
}
// OutputService1TestCaseOperation1Request generates a request for the OutputService1TestCaseOperation1 operation.
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (req *aws.Request, output *OutputService1TestShapeOutputShape) {
if opOutputService1TestCaseOperation1 == nil {
opOutputService1TestCaseOperation1 = &aws.Operation{
Name: "OperationName",
}
}
req = aws.NewRequest(c.Service, opOutputService1TestCaseOperation1, input, output)
output = &OutputService1TestShapeOutputShape{}
req.Data = output
return
}
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation1(input *OutputService1TestShapeOutputService1TestCaseOperation1Input) (output *OutputService1TestShapeOutputShape, err error) {
req, out := c.OutputService1TestCaseOperation1Request(input)
output = out
err = req.Send()
return
}
var opOutputService1TestCaseOperation1 *aws.Operation
// OutputService1TestCaseOperation2Request generates a request for the OutputService1TestCaseOperation2 operation.
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2Request(input *OutputService1TestShapeOutputService1TestCaseOperation2Input) (req *aws.Request, output *OutputService1TestShapeOutputShape) {
if opOutputService1TestCaseOperation2 == nil {
opOutputService1TestCaseOperation2 = &aws.Operation{
Name: "OperationName",
}
}
req = aws.NewRequest(c.Service, opOutputService1TestCaseOperation2, input, output)
output = &OutputService1TestShapeOutputShape{}
req.Data = output
return
}
func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2(input *OutputService1TestShapeOutputService1TestCaseOperation2Input) (output *OutputService1TestShapeOutputShape, err error) {
req, out := c.OutputService1TestCaseOperation2Request(input)
output = out
err = req.Send()
return
}
var opOutputService1TestCaseOperation2 *aws.Operation
type OutputService1TestShapeOutputService1TestCaseOperation1Input struct {
metadataOutputService1TestShapeOutputService1TestCaseOperation1Input `json:"-", xml:"-"`
}
type metadataOutputService1TestShapeOutputService1TestCaseOperation1Input struct {
SDKShapeTraits bool `type:"structure"`
}
type OutputService1TestShapeOutputService1TestCaseOperation2Input struct {
metadataOutputService1TestShapeOutputService1TestCaseOperation2Input `json:"-", xml:"-"`
}
type metadataOutputService1TestShapeOutputService1TestCaseOperation2Input struct {
SDKShapeTraits bool `type:"structure"`
}
type OutputService1TestShapeOutputShape struct {
Char *string `type:"character"`
Double *float64 `type:"double"`
FalseBool *bool `type:"boolean"`
Float *float64 `type:"float"`
ImaHeader *string `location:"header" type:"string"`
ImaHeaderLocation *string `location:"header" locationName:"X-Foo" type:"string"`
Long *int64 `type:"long"`
Num *int64 `locationName:"FooNum" type:"integer"`
Str *string `type:"string"`
Timestamp *time.Time `type:"timestamp" timestampFormat:"iso8601"`
TrueBool *bool `type:"boolean"`
metadataOutputService1TestShapeOutputShape `json:"-", xml:"-"`
}
type metadataOutputService1TestShapeOutputShape struct {
SDKShapeTraits bool `type:"structure"`
}
// OutputService2ProtocolTest is a client for OutputService2ProtocolTest.
type OutputService2ProtocolTest struct {
*aws.Service
}
// New returns a new OutputService2ProtocolTest client.
func NewOutputService2ProtocolTest(config *aws.Config) *OutputService2ProtocolTest {
if config == nil {
config = &aws.Config{}
}
service := &aws.Service{
Config: aws.DefaultConfig.Merge(config),
ServiceName: "outputservice2protocoltest",
APIVersion: "",
}
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 &OutputService2ProtocolTest{service}
}
// OutputService2TestCaseOperation1Request generates a request for the OutputService2TestCaseOperation1 operation.
func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1Request(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (req *aws.Request, output *OutputService2TestShapeOutputShape) {
if opOutputService2TestCaseOperation1 == nil {
opOutputService2TestCaseOperation1 = &aws.Operation{
Name: "OperationName",
}
}
req = aws.NewRequest(c.Service, opOutputService2TestCaseOperation1, input, output)
output = &OutputService2TestShapeOutputShape{}
req.Data = output
return
}
func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (output *OutputService2TestShapeOutputShape, err error) {
req, out := c.OutputService2TestCaseOperation1Request(input)
output = out
err = req.Send()
return
}
var opOutputService2TestCaseOperation1 *aws.Operation
type OutputService2TestShapeOutputService2TestCaseOperation1Input struct {
metadataOutputService2TestShapeOutputService2TestCaseOperation1Input `json:"-", xml:"-"`
}
type metadataOutputService2TestShapeOutputService2TestCaseOperation1Input struct {
SDKShapeTraits bool `type:"structure"`
}
type OutputService2TestShapeOutputShape struct {
Blob []byte `type:"blob"`
metadataOutputService2TestShapeOutputShape `json:"-", xml:"-"`
}
type metadataOutputService2TestShapeOutputShape struct {
SDKShapeTraits bool `type:"structure"`
}
// OutputService3ProtocolTest is a client for OutputService3ProtocolTest.
type OutputService3ProtocolTest struct {
*aws.Service
}
// New returns a new OutputService3ProtocolTest client.
func NewOutputService3ProtocolTest(config *aws.Config) *OutputService3ProtocolTest {
if config == nil {
config = &aws.Config{}
}
service := &aws.Service{
Config: aws.DefaultConfig.Merge(config),
ServiceName: "outputservice3protocoltest",
APIVersion: "",
}
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 &OutputService3ProtocolTest{service}
}
// OutputService3TestCaseOperation1Request generates a request for the OutputService3TestCaseOperation1 operation.
func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1Request(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (req *aws.Request, output *OutputService3TestShapeOutputShape) {
if opOutputService3TestCaseOperation1 == nil {
opOutputService3TestCaseOperation1 = &aws.Operation{
Name: "OperationName",
}
}
req = aws.NewRequest(c.Service, opOutputService3TestCaseOperation1, input, output)
output = &OutputService3TestShapeOutputShape{}
req.Data = output
return
}
func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (output *OutputService3TestShapeOutputShape, err error) {
req, out := c.OutputService3TestCaseOperation1Request(input)
output = out
err = req.Send()
return
}
var opOutputService3TestCaseOperation1 *aws.Operation
type OutputService3TestShapeOutputService3TestCaseOperation1Input struct {
metadataOutputService3TestShapeOutputService3TestCaseOperation1Input `json:"-", xml:"-"`
}
type metadataOutputService3TestShapeOutputService3TestCaseOperation1Input struct {
SDKShapeTraits bool `type:"structure"`
}
type OutputService3TestShapeOutputShape struct {
ListMember []*string `type:"list"`
metadataOutputService3TestShapeOutputShape `json:"-", xml:"-"`
}
type metadataOutputService3TestShapeOutputShape struct {
SDKShapeTraits bool `type:"structure"`
}
// OutputService4ProtocolTest is a client for OutputService4ProtocolTest.
type OutputService4ProtocolTest struct {
*aws.Service
}
// New returns a new OutputService4ProtocolTest client.
func NewOutputService4ProtocolTest(config *aws.Config) *OutputService4ProtocolTest {
if config == nil {
config = &aws.Config{}
}
service := &aws.Service{
Config: aws.DefaultConfig.Merge(config),
ServiceName: "outputservice4protocoltest",
APIVersion: "",
}
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 &OutputService4ProtocolTest{service}
}
// OutputService4TestCaseOperation1Request generates a request for the OutputService4TestCaseOperation1 operation.
func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (req *aws.Request, output *OutputService4TestShapeOutputShape) {
if opOutputService4TestCaseOperation1 == nil {
opOutputService4TestCaseOperation1 = &aws.Operation{
Name: "OperationName",
}
}
req = aws.NewRequest(c.Service, opOutputService4TestCaseOperation1, input, output)
output = &OutputService4TestShapeOutputShape{}
req.Data = output
return
}
func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (output *OutputService4TestShapeOutputShape, err error) {
req, out := c.OutputService4TestCaseOperation1Request(input)
output = out
err = req.Send()
return
}
var opOutputService4TestCaseOperation1 *aws.Operation
type OutputService4TestShapeOutputService4TestCaseOperation1Input struct {
metadataOutputService4TestShapeOutputService4TestCaseOperation1Input `json:"-", xml:"-"`
}
type metadataOutputService4TestShapeOutputService4TestCaseOperation1Input struct {
SDKShapeTraits bool `type:"structure"`
}
type OutputService4TestShapeOutputShape struct {
ListMember []*string `locationNameList:"item" type:"list"`
metadataOutputService4TestShapeOutputShape `json:"-", xml:"-"`
}
type metadataOutputService4TestShapeOutputShape struct {
SDKShapeTraits bool `type:"structure"`
}
// OutputService5ProtocolTest is a client for OutputService5ProtocolTest.
type OutputService5ProtocolTest struct {
*aws.Service
}
// New returns a new OutputService5ProtocolTest client.
func NewOutputService5ProtocolTest(config *aws.Config) *OutputService5ProtocolTest {
if config == nil {
config = &aws.Config{}
}
service := &aws.Service{
Config: aws.DefaultConfig.Merge(config),
ServiceName: "outputservice5protocoltest",
APIVersion: "",
}
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 &OutputService5ProtocolTest{service}
}
// OutputService5TestCaseOperation1Request generates a request for the OutputService5TestCaseOperation1 operation.
func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1Request(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (req *aws.Request, output *OutputService5TestShapeOutputShape) {
if opOutputService5TestCaseOperation1 == nil {
opOutputService5TestCaseOperation1 = &aws.Operation{
Name: "OperationName",
}
}
req = aws.NewRequest(c.Service, opOutputService5TestCaseOperation1, input, output)
output = &OutputService5TestShapeOutputShape{}
req.Data = output
return
}
func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (output *OutputService5TestShapeOutputShape, err error) {
req, out := c.OutputService5TestCaseOperation1Request(input)
output = out
err = req.Send()
return
}
var opOutputService5TestCaseOperation1 *aws.Operation
type OutputService5TestShapeOutputService5TestCaseOperation1Input struct {
metadataOutputService5TestShapeOutputService5TestCaseOperation1Input `json:"-", xml:"-"`
}
type metadataOutputService5TestShapeOutputService5TestCaseOperation1Input struct {
SDKShapeTraits bool `type:"structure"`
}
type OutputService5TestShapeOutputShape struct {
ListMember []*string `type:"list" flattened:"true"`
metadataOutputService5TestShapeOutputShape `json:"-", xml:"-"`
}
type metadataOutputService5TestShapeOutputShape struct {
SDKShapeTraits bool `type:"structure"`
}
// OutputService6ProtocolTest is a client for OutputService6ProtocolTest.
type OutputService6ProtocolTest struct {
*aws.Service
}
// New returns a new OutputService6ProtocolTest client.
func NewOutputService6ProtocolTest(config *aws.Config) *OutputService6ProtocolTest {
if config == nil {
config = &aws.Config{}
}
service := &aws.Service{
Config: aws.DefaultConfig.Merge(config),
ServiceName: "outputservice6protocoltest",
APIVersion: "",
}
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 &OutputService6ProtocolTest{service}
}
// OutputService6TestCaseOperation1Request generates a request for the OutputService6TestCaseOperation1 operation.
func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1Request(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (req *aws.Request, output *OutputService6TestShapeOutputShape) {
if opOutputService6TestCaseOperation1 == nil {
opOutputService6TestCaseOperation1 = &aws.Operation{
Name: "OperationName",
}
}
req = aws.NewRequest(c.Service, opOutputService6TestCaseOperation1, input, output)
output = &OutputService6TestShapeOutputShape{}
req.Data = output
return
}
func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (output *OutputService6TestShapeOutputShape, err error) {
req, out := c.OutputService6TestCaseOperation1Request(input)
output = out
err = req.Send()
return
}
var opOutputService6TestCaseOperation1 *aws.Operation
type OutputService6TestShapeOutputService6TestCaseOperation1Input struct {
metadataOutputService6TestShapeOutputService6TestCaseOperation1Input `json:"-", xml:"-"`
}
type metadataOutputService6TestShapeOutputService6TestCaseOperation1Input struct {
SDKShapeTraits bool `type:"structure"`
}
type OutputService6TestShapeOutputShape struct {
Map *map[string]*OutputService6TestShapeSingleStructure `type:"map"`
metadataOutputService6TestShapeOutputShape `json:"-", xml:"-"`
}
type metadataOutputService6TestShapeOutputShape struct {
SDKShapeTraits bool `type:"structure"`
}
type OutputService6TestShapeSingleStructure struct {
Foo *string `locationName:"foo" type:"string"`
metadataOutputService6TestShapeSingleStructure `json:"-", xml:"-"`
}
type metadataOutputService6TestShapeSingleStructure struct {
SDKShapeTraits bool `type:"structure"`
}
// OutputService7ProtocolTest is a client for OutputService7ProtocolTest.
type OutputService7ProtocolTest struct {
*aws.Service
}
// New returns a new OutputService7ProtocolTest client.
func NewOutputService7ProtocolTest(config *aws.Config) *OutputService7ProtocolTest {
if config == nil {
config = &aws.Config{}
}
service := &aws.Service{
Config: aws.DefaultConfig.Merge(config),
ServiceName: "outputservice7protocoltest",
APIVersion: "",
}
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 &OutputService7ProtocolTest{service}
}
// OutputService7TestCaseOperation1Request generates a request for the OutputService7TestCaseOperation1 operation.
func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1Request(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (req *aws.Request, output *OutputService7TestShapeOutputShape) {
if opOutputService7TestCaseOperation1 == nil {
opOutputService7TestCaseOperation1 = &aws.Operation{
Name: "OperationName",
}
}
req = aws.NewRequest(c.Service, opOutputService7TestCaseOperation1, input, output)
output = &OutputService7TestShapeOutputShape{}
req.Data = output
return
}
func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (output *OutputService7TestShapeOutputShape, err error) {
req, out := c.OutputService7TestCaseOperation1Request(input)
output = out
err = req.Send()
return
}
var opOutputService7TestCaseOperation1 *aws.Operation
type OutputService7TestShapeOutputService7TestCaseOperation1Input struct {
metadataOutputService7TestShapeOutputService7TestCaseOperation1Input `json:"-", xml:"-"`
}
type metadataOutputService7TestShapeOutputService7TestCaseOperation1Input struct {
SDKShapeTraits bool `type:"structure"`
}
type OutputService7TestShapeOutputShape struct {
Map *map[string]*string `type:"map" flattened:"true"`
metadataOutputService7TestShapeOutputShape `json:"-", xml:"-"`
}
type metadataOutputService7TestShapeOutputShape struct {
SDKShapeTraits bool `type:"structure"`
}
// OutputService8ProtocolTest is a client for OutputService8ProtocolTest.
type OutputService8ProtocolTest struct {
*aws.Service
}
// New returns a new OutputService8ProtocolTest client.
func NewOutputService8ProtocolTest(config *aws.Config) *OutputService8ProtocolTest {
if config == nil {
config = &aws.Config{}
}
service := &aws.Service{
Config: aws.DefaultConfig.Merge(config),
ServiceName: "outputservice8protocoltest",
APIVersion: "",
}
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 &OutputService8ProtocolTest{service}
}
// OutputService8TestCaseOperation1Request generates a request for the OutputService8TestCaseOperation1 operation.
func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1Request(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (req *aws.Request, output *OutputService8TestShapeOutputShape) {
if opOutputService8TestCaseOperation1 == nil {
opOutputService8TestCaseOperation1 = &aws.Operation{
Name: "OperationName",
}
}
req = aws.NewRequest(c.Service, opOutputService8TestCaseOperation1, input, output)
output = &OutputService8TestShapeOutputShape{}
req.Data = output
return
}
func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (output *OutputService8TestShapeOutputShape, err error) {
req, out := c.OutputService8TestCaseOperation1Request(input)
output = out
err = req.Send()
return
}
var opOutputService8TestCaseOperation1 *aws.Operation
type OutputService8TestShapeOutputService8TestCaseOperation1Input struct {
metadataOutputService8TestShapeOutputService8TestCaseOperation1Input `json:"-", xml:"-"`
}
type metadataOutputService8TestShapeOutputService8TestCaseOperation1Input struct {
SDKShapeTraits bool `type:"structure"`
}
type OutputService8TestShapeOutputShape struct {
Map *map[string]*string `locationNameKey:"foo" locationNameValue:"bar" type:"map"`
metadataOutputService8TestShapeOutputShape `json:"-", xml:"-"`
}
type metadataOutputService8TestShapeOutputShape struct {
SDKShapeTraits bool `type:"structure"`
}
// OutputService9ProtocolTest is a client for OutputService9ProtocolTest.
type OutputService9ProtocolTest struct {
*aws.Service
}
// New returns a new OutputService9ProtocolTest client.
func NewOutputService9ProtocolTest(config *aws.Config) *OutputService9ProtocolTest {
if config == nil {
config = &aws.Config{}
}
service := &aws.Service{
Config: aws.DefaultConfig.Merge(config),
ServiceName: "outputservice9protocoltest",
APIVersion: "",
}
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 &OutputService9ProtocolTest{service}
}
// OutputService9TestCaseOperation1Request generates a request for the OutputService9TestCaseOperation1 operation.
func (c *OutputService9ProtocolTest) OutputService9TestCaseOperation1Request(input *OutputService9TestShapeOutputService9TestCaseOperation1Input) (req *aws.Request, output *OutputService9TestShapeOutputShape) {
if opOutputService9TestCaseOperation1 == nil {
opOutputService9TestCaseOperation1 = &aws.Operation{
Name: "OperationName",
}
}
req = aws.NewRequest(c.Service, opOutputService9TestCaseOperation1, input, output)
output = &OutputService9TestShapeOutputShape{}
req.Data = output
return
}
func (c *OutputService9ProtocolTest) OutputService9TestCaseOperation1(input *OutputService9TestShapeOutputService9TestCaseOperation1Input) (output *OutputService9TestShapeOutputShape, err error) {
req, out := c.OutputService9TestCaseOperation1Request(input)
output = out
err = req.Send()
return
}
var opOutputService9TestCaseOperation1 *aws.Operation
type OutputService9TestShapeOutputService9TestCaseOperation1Input struct {
metadataOutputService9TestShapeOutputService9TestCaseOperation1Input `json:"-", xml:"-"`
}
type metadataOutputService9TestShapeOutputService9TestCaseOperation1Input struct {
SDKShapeTraits bool `type:"structure"`
}
type OutputService9TestShapeOutputShape struct {
Data *OutputService9TestShapeSingleStructure `type:"structure"`
Header *string `location:"header" locationName:"X-Foo" type:"string"`
metadataOutputService9TestShapeOutputShape `json:"-", xml:"-"`
}
type metadataOutputService9TestShapeOutputShape struct {
SDKShapeTraits bool `type:"structure" payload:"Data"`
}
type OutputService9TestShapeSingleStructure struct {
Foo *string `type:"string"`
metadataOutputService9TestShapeSingleStructure `json:"-", xml:"-"`
}
type metadataOutputService9TestShapeSingleStructure struct {
SDKShapeTraits bool `type:"structure"`
}
// OutputService10ProtocolTest is a client for OutputService10ProtocolTest.
type OutputService10ProtocolTest struct {
*aws.Service
}
// New returns a new OutputService10ProtocolTest client.
func NewOutputService10ProtocolTest(config *aws.Config) *OutputService10ProtocolTest {
if config == nil {
config = &aws.Config{}
}
service := &aws.Service{
Config: aws.DefaultConfig.Merge(config),
ServiceName: "outputservice10protocoltest",
APIVersion: "",
}
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 &OutputService10ProtocolTest{service}
}
// OutputService10TestCaseOperation1Request generates a request for the OutputService10TestCaseOperation1 operation.
func (c *OutputService10ProtocolTest) OutputService10TestCaseOperation1Request(input *OutputService10TestShapeOutputService10TestCaseOperation1Input) (req *aws.Request, output *OutputService10TestShapeOutputShape) {
if opOutputService10TestCaseOperation1 == nil {
opOutputService10TestCaseOperation1 = &aws.Operation{
Name: "OperationName",
}
}
req = aws.NewRequest(c.Service, opOutputService10TestCaseOperation1, input, output)
output = &OutputService10TestShapeOutputShape{}
req.Data = output
return
}
func (c *OutputService10ProtocolTest) OutputService10TestCaseOperation1(input *OutputService10TestShapeOutputService10TestCaseOperation1Input) (output *OutputService10TestShapeOutputShape, err error) {
req, out := c.OutputService10TestCaseOperation1Request(input)
output = out
err = req.Send()
return
}
var opOutputService10TestCaseOperation1 *aws.Operation
type OutputService10TestShapeOutputService10TestCaseOperation1Input struct {
metadataOutputService10TestShapeOutputService10TestCaseOperation1Input `json:"-", xml:"-"`
}
type metadataOutputService10TestShapeOutputService10TestCaseOperation1Input struct {
SDKShapeTraits bool `type:"structure"`
}
type OutputService10TestShapeOutputShape struct {
Stream []byte `type:"blob"`
metadataOutputService10TestShapeOutputShape `json:"-", xml:"-"`
}
type metadataOutputService10TestShapeOutputShape struct {
SDKShapeTraits bool `type:"structure" payload:"Stream"`
}
// OutputService11ProtocolTest is a client for OutputService11ProtocolTest.
type OutputService11ProtocolTest struct {
*aws.Service
}
// New returns a new OutputService11ProtocolTest client.
func NewOutputService11ProtocolTest(config *aws.Config) *OutputService11ProtocolTest {
if config == nil {
config = &aws.Config{}
}
service := &aws.Service{
Config: aws.DefaultConfig.Merge(config),
ServiceName: "outputservice11protocoltest",
APIVersion: "",
}
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 &OutputService11ProtocolTest{service}
}
// OutputService11TestCaseOperation1Request generates a request for the OutputService11TestCaseOperation1 operation.
func (c *OutputService11ProtocolTest) OutputService11TestCaseOperation1Request(input *OutputService11TestShapeOutputService11TestCaseOperation1Input) (req *aws.Request, output *OutputService11TestShapeOutputShape) {
if opOutputService11TestCaseOperation1 == nil {
opOutputService11TestCaseOperation1 = &aws.Operation{
Name: "OperationName",
}
}
req = aws.NewRequest(c.Service, opOutputService11TestCaseOperation1, input, output)
output = &OutputService11TestShapeOutputShape{}
req.Data = output
return
}
func (c *OutputService11ProtocolTest) OutputService11TestCaseOperation1(input *OutputService11TestShapeOutputService11TestCaseOperation1Input) (output *OutputService11TestShapeOutputShape, err error) {
req, out := c.OutputService11TestCaseOperation1Request(input)
output = out
err = req.Send()
return
}
var opOutputService11TestCaseOperation1 *aws.Operation
type OutputService11TestShapeOutputService11TestCaseOperation1Input struct {
metadataOutputService11TestShapeOutputService11TestCaseOperation1Input `json:"-", xml:"-"`
}
type metadataOutputService11TestShapeOutputService11TestCaseOperation1Input struct {
SDKShapeTraits bool `type:"structure"`
}
type OutputService11TestShapeOutputShape struct {
Char *string `location:"header" locationName:"x-char" type:"character"`
Double *float64 `location:"header" locationName:"x-double" type:"double"`
FalseBool *bool `location:"header" locationName:"x-false-bool" type:"boolean"`
Float *float64 `location:"header" locationName:"x-float" type:"float"`
Integer *int64 `location:"header" locationName:"x-int" type:"integer"`
Long *int64 `location:"header" locationName:"x-long" type:"long"`
Str *string `location:"header" locationName:"x-str" type:"string"`
Timestamp *time.Time `location:"header" locationName:"x-timestamp" type:"timestamp" timestampFormat:"iso8601"`
TrueBool *bool `location:"header" locationName:"x-true-bool" type:"boolean"`
metadataOutputService11TestShapeOutputShape `json:"-", xml:"-"`
}
type metadataOutputService11TestShapeOutputShape struct {
SDKShapeTraits bool `type:"structure"`
}
//
// Tests begin here
//
func TestOutputService1ProtocolTestScalarMembersCase1(t *testing.T) {
svc := NewOutputService1ProtocolTest(nil)
buf := bytes.NewReader([]byte("myname123falsetrue1.21.3200a2015-01-25T08:00:00Z"))
req, out := svc.OutputService1TestCaseOperation1Request(nil)
req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
// set headers
req.HTTPResponse.Header.Set("ImaHeader", "test")
req.HTTPResponse.Header.Set("X-Foo", "abc")
// unmarshal response
restxml.UnmarshalMeta(req)
restxml.Unmarshal(req)
assert.NoError(t, req.Error)
// assert response
assert.NotNil(t, out) // ensure out variable is used
assert.Equal(t, "a", *out.Char)
assert.Equal(t, 1.3, *out.Double)
assert.Equal(t, false, *out.FalseBool)
assert.Equal(t, 1.2, *out.Float)
assert.Equal(t, "test", *out.ImaHeader)
assert.Equal(t, "abc", *out.ImaHeaderLocation)
assert.Equal(t, 200, *out.Long)
assert.Equal(t, 123, *out.Num)
assert.Equal(t, "myname", *out.Str)
assert.Equal(t, time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.String())
assert.Equal(t, true, *out.TrueBool)
}
func TestOutputService1ProtocolTestScalarMembersCase2(t *testing.T) {
svc := NewOutputService1ProtocolTest(nil)
buf := bytes.NewReader([]byte("123falsetrue1.21.3200a2015-01-25T08:00:00Z"))
req, out := svc.OutputService1TestCaseOperation2Request(nil)
req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
// set headers
req.HTTPResponse.Header.Set("ImaHeader", "test")
req.HTTPResponse.Header.Set("X-Foo", "abc")
// unmarshal response
restxml.UnmarshalMeta(req)
restxml.Unmarshal(req)
assert.NoError(t, req.Error)
// assert response
assert.NotNil(t, out) // ensure out variable is used
assert.Equal(t, "a", *out.Char)
assert.Equal(t, 1.3, *out.Double)
assert.Equal(t, false, *out.FalseBool)
assert.Equal(t, 1.2, *out.Float)
assert.Equal(t, "test", *out.ImaHeader)
assert.Equal(t, "abc", *out.ImaHeaderLocation)
assert.Equal(t, 200, *out.Long)
assert.Equal(t, 123, *out.Num)
assert.Equal(t, "", *out.Str)
assert.Equal(t, time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.String())
assert.Equal(t, true, *out.TrueBool)
}
func TestOutputService2ProtocolTestBlobCase1(t *testing.T) {
svc := NewOutputService2ProtocolTest(nil)
buf := bytes.NewReader([]byte("dmFsdWU="))
req, out := svc.OutputService2TestCaseOperation1Request(nil)
req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
// set headers
// unmarshal response
restxml.UnmarshalMeta(req)
restxml.Unmarshal(req)
assert.NoError(t, req.Error)
// assert response
assert.NotNil(t, out) // ensure out variable is used
assert.Equal(t, "value", string(out.Blob))
}
func TestOutputService3ProtocolTestListsCase1(t *testing.T) {
svc := NewOutputService3ProtocolTest(nil)
buf := bytes.NewReader([]byte("abc123"))
req, out := svc.OutputService3TestCaseOperation1Request(nil)
req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
// set headers
// unmarshal response
restxml.UnmarshalMeta(req)
restxml.Unmarshal(req)
assert.NoError(t, req.Error)
// assert response
assert.NotNil(t, out) // ensure out variable is used
assert.Equal(t, "abc", *out.ListMember[0])
assert.Equal(t, "123", *out.ListMember[1])
}
func TestOutputService4ProtocolTestListWithCustomMemberNameCase1(t *testing.T) {
svc := NewOutputService4ProtocolTest(nil)
buf := bytes.NewReader([]byte("- abc
- 123
"))
req, out := svc.OutputService4TestCaseOperation1Request(nil)
req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
// set headers
// unmarshal response
restxml.UnmarshalMeta(req)
restxml.Unmarshal(req)
assert.NoError(t, req.Error)
// assert response
assert.NotNil(t, out) // ensure out variable is used
assert.Equal(t, "abc", *out.ListMember[0])
assert.Equal(t, "123", *out.ListMember[1])
}
func TestOutputService5ProtocolTestFlattenedListCase1(t *testing.T) {
svc := NewOutputService5ProtocolTest(nil)
buf := bytes.NewReader([]byte("abc123"))
req, out := svc.OutputService5TestCaseOperation1Request(nil)
req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
// set headers
// unmarshal response
restxml.UnmarshalMeta(req)
restxml.Unmarshal(req)
assert.NoError(t, req.Error)
// assert response
assert.NotNil(t, out) // ensure out variable is used
assert.Equal(t, "abc", *out.ListMember[0])
assert.Equal(t, "123", *out.ListMember[1])
}
func TestOutputService6ProtocolTestNormalMapCase1(t *testing.T) {
svc := NewOutputService6ProtocolTest(nil)
buf := bytes.NewReader([]byte(""))
req, out := svc.OutputService6TestCaseOperation1Request(nil)
req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
// set headers
// unmarshal response
restxml.UnmarshalMeta(req)
restxml.Unmarshal(req)
assert.NoError(t, req.Error)
// assert response
assert.NotNil(t, out) // ensure out variable is used
assert.Equal(t, "bam", *(*out.Map)["baz"].Foo)
assert.Equal(t, "bar", *(*out.Map)["qux"].Foo)
}
func TestOutputService7ProtocolTestFlattenedMapCase1(t *testing.T) {
svc := NewOutputService7ProtocolTest(nil)
buf := bytes.NewReader([]byte(""))
req, out := svc.OutputService7TestCaseOperation1Request(nil)
req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
// set headers
// unmarshal response
restxml.UnmarshalMeta(req)
restxml.Unmarshal(req)
assert.NoError(t, req.Error)
// assert response
assert.NotNil(t, out) // ensure out variable is used
assert.Equal(t, "bam", *(*out.Map)["baz"])
assert.Equal(t, "bar", *(*out.Map)["qux"])
}
func TestOutputService8ProtocolTestNamedMapCase1(t *testing.T) {
svc := NewOutputService8ProtocolTest(nil)
buf := bytes.NewReader([]byte(""))
req, out := svc.OutputService8TestCaseOperation1Request(nil)
req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
// set headers
// unmarshal response
restxml.UnmarshalMeta(req)
restxml.Unmarshal(req)
assert.NoError(t, req.Error)
// assert response
assert.NotNil(t, out) // ensure out variable is used
assert.Equal(t, "bam", *(*out.Map)["baz"])
assert.Equal(t, "bar", *(*out.Map)["qux"])
}
func TestOutputService9ProtocolTestXMLPayloadCase1(t *testing.T) {
svc := NewOutputService9ProtocolTest(nil)
buf := bytes.NewReader([]byte("abc"))
req, out := svc.OutputService9TestCaseOperation1Request(nil)
req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
// set headers
req.HTTPResponse.Header.Set("X-Foo", "baz")
// unmarshal response
restxml.UnmarshalMeta(req)
restxml.Unmarshal(req)
assert.NoError(t, req.Error)
// assert response
assert.NotNil(t, out) // ensure out variable is used
assert.Equal(t, "abc", *out.Data.Foo)
assert.Equal(t, "baz", *out.Header)
}
func TestOutputService10ProtocolTestStreamingPayloadCase1(t *testing.T) {
svc := NewOutputService10ProtocolTest(nil)
buf := bytes.NewReader([]byte("abc"))
req, out := svc.OutputService10TestCaseOperation1Request(nil)
req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
// set headers
// unmarshal response
restxml.UnmarshalMeta(req)
restxml.Unmarshal(req)
assert.NoError(t, req.Error)
// assert response
assert.NotNil(t, out) // ensure out variable is used
assert.Equal(t, "abc", string(out.Stream))
}
func TestOutputService11ProtocolTestScalarMembersInHeadersCase1(t *testing.T) {
svc := NewOutputService11ProtocolTest(nil)
buf := bytes.NewReader([]byte(""))
req, out := svc.OutputService11TestCaseOperation1Request(nil)
req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}}
// set headers
req.HTTPResponse.Header.Set("x-char", "a")
req.HTTPResponse.Header.Set("x-double", "1.5")
req.HTTPResponse.Header.Set("x-false-bool", "false")
req.HTTPResponse.Header.Set("x-float", "1.5")
req.HTTPResponse.Header.Set("x-int", "1")
req.HTTPResponse.Header.Set("x-long", "100")
req.HTTPResponse.Header.Set("x-str", "string")
req.HTTPResponse.Header.Set("x-timestamp", "Sun, 25 Jan 2015 08:00:00 GMT")
req.HTTPResponse.Header.Set("x-true-bool", "true")
// unmarshal response
restxml.UnmarshalMeta(req)
restxml.Unmarshal(req)
assert.NoError(t, req.Error)
// assert response
assert.NotNil(t, out) // ensure out variable is used
assert.Equal(t, "a", *out.Char)
assert.Equal(t, 1.5, *out.Double)
assert.Equal(t, false, *out.FalseBool)
assert.Equal(t, 1.5, *out.Float)
assert.Equal(t, 1, *out.Integer)
assert.Equal(t, 100, *out.Long)
assert.Equal(t, "string", *out.Str)
assert.Equal(t, time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.String())
assert.Equal(t, true, *out.TrueBool)
}