Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 build_bench_test.go //go:build bench // +build bench package jsonrpc_test import ( "bytes" "encoding/json" "testing" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/awstesting" "github.com/aws/aws-sdk-go/private/protocol/json/jsonutil" "github.com/aws/aws-sdk-go/private/protocol/jsonrpc" "github.com/aws/aws-sdk-go/service/dynamodb" "github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute" ) func BenchmarkJSONRPCBuild_Simple_dynamodbPutItem(b testing.B) { svc := awstesting.NewClient() params := getDynamodbPutItemParams(b) for i := 0; i < b.N; i++ { r := svc.NewRequest(&request.Operation{Name: "Operation"}, params, nil) jsonrpc.Build(r) if r.Error != nil { b.Fatal("Unexpected error", r.Error) } } } func BenchmarkJSONUtilBuild_Simple_dynamodbPutItem(b testing.B) { svc := awstesting.NewClient() params := getDynamodbPutItemParams(b) for i := 0; i < b.N; i++ { r := svc.NewRequest(&request.Operation{Name: "Operation"}, params, nil) _, err := jsonutil.BuildJSON(r.Params) if err != nil { b.Fatal("Unexpected error", err) } } } func BenchmarkEncodingJSONMarshal_Simple_dynamodbPutItem(b testing.B) { params := getDynamodbPutItemParams(b) for i := 0; i < b.N; i++ { buf := &bytes.Buffer{} encoder := json.NewEncoder(buf) if err := encoder.Encode(params); err != nil { b.Fatal("Unexpected error", err) } } } func getDynamodbPutItemParams(b testing.B) *dynamodb.PutItemInput { av, err := dynamodbattribute.ConvertToMap(struct { Key string Data string }{Key: "MyKey", Data: "MyData"}) if err != nil { b.Fatal("benchPutItem, expect no ConvertToMap errors", err) } return &dynamodb.PutItemInput{ Item: av, TableName: aws.String("tablename"), } }	1.73 KB	2025-05-25 12:27
📄 build_test.go // Code generated by models/protocol_tests/generate.go. DO NOT EDIT. package jsonrpc_test import ( "bytes" "encoding/json" "encoding/xml" "fmt" "io" "io/ioutil" "net/http" "net/url" "reflect" "testing" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/client" "github.com/aws/aws-sdk-go/aws/client/metadata" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/aws/signer/v4" "github.com/aws/aws-sdk-go/awstesting" "github.com/aws/aws-sdk-go/awstesting/unit" "github.com/aws/aws-sdk-go/private/protocol" "github.com/aws/aws-sdk-go/private/protocol/jsonrpc" "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil" "github.com/aws/aws-sdk-go/private/util" ) 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 var _ = aws.String var _ = fmt.Println var _ = reflect.Value{} func init() { protocol.RandReader = &awstesting.ZeroReader{} } // InputService1ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService1ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService1ProtocolTest struct { client.Client } // New creates a new instance of the InputService1ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a InputService1ProtocolTest client from just a session. // svc := inputservice1protocoltest.New(mySession) // // // Create a InputService1ProtocolTest client with additional configuration // svc := inputservice1protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService1ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService1ProtocolTest { c := p.ClientConfig("inputservice1protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService1ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService1ProtocolTest { svc := &InputService1ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService1ProtocolTest", ServiceID: "InputService1ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, JSONVersion: "1.1", TargetPrefix: "com.amazonaws.foo", }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // 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 "aws/request.Request" representing the // client's request for the InputService1TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService1TestCaseOperation1 for more information on using the InputService1TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService1TestCaseOperation1Request method. // req, resp := client.InputService1TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService1ProtocolTest) InputService1TestCaseOperation1Request(input InputService1TestShapeInputService1TestCaseOperation1Input) (req request.Request, output InputService1TestShapeInputService1TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService1TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService1TestShapeInputService1TestCaseOperation1Input{} } output = &InputService1TestShapeInputService1TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService1TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService1TestCaseOperation1 for usage and error information. func (c InputService1ProtocolTest) InputService1TestCaseOperation1(input InputService1TestShapeInputService1TestCaseOperation1Input) (InputService1TestShapeInputService1TestCaseOperation1Output, error) { req, out := c.InputService1TestCaseOperation1Request(input) return out, req.Send() } // InputService1TestCaseOperation1WithContext is the same as InputService1TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService1TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService1ProtocolTest) InputService1TestCaseOperation1WithContext(ctx aws.Context, input InputService1TestShapeInputService1TestCaseOperation1Input, opts ...request.Option) (InputService1TestShapeInputService1TestCaseOperation1Output, error) { req, out := c.InputService1TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService1TestShapeInputService1TestCaseOperation1Input struct { _ struct{} `type:"structure"` Name string `type:"string"` } // SetName sets the Name field's value. func (s InputService1TestShapeInputService1TestCaseOperation1Input) SetName(v string) InputService1TestShapeInputService1TestCaseOperation1Input { s.Name = &v return s } type InputService1TestShapeInputService1TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // InputService2ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService2ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService2ProtocolTest struct { client.Client } // New creates a new instance of the InputService2ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a InputService2ProtocolTest client from just a session. // svc := inputservice2protocoltest.New(mySession) // // // Create a InputService2ProtocolTest client with additional configuration // svc := inputservice2protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService2ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService2ProtocolTest { c := p.ClientConfig("inputservice2protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService2ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService2ProtocolTest { svc := &InputService2ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService2ProtocolTest", ServiceID: "InputService2ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, JSONVersion: "1.1", TargetPrefix: "com.amazonaws.foo", }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // 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 "aws/request.Request" representing the // client's request for the InputService2TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService2TestCaseOperation1 for more information on using the InputService2TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService2TestCaseOperation1Request method. // req, resp := client.InputService2TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService2ProtocolTest) InputService2TestCaseOperation1Request(input InputService2TestShapeInputService2TestCaseOperation1Input) (req request.Request, output InputService2TestShapeInputService2TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService2TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &InputService2TestShapeInputService2TestCaseOperation1Input{} } output = &InputService2TestShapeInputService2TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService2TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService2TestCaseOperation1 for usage and error information. func (c InputService2ProtocolTest) InputService2TestCaseOperation1(input InputService2TestShapeInputService2TestCaseOperation1Input) (InputService2TestShapeInputService2TestCaseOperation1Output, error) { req, out := c.InputService2TestCaseOperation1Request(input) return out, req.Send() } // InputService2TestCaseOperation1WithContext is the same as InputService2TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService2TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService2ProtocolTest) InputService2TestCaseOperation1WithContext(ctx aws.Context, input InputService2TestShapeInputService2TestCaseOperation1Input, opts ...request.Option) (InputService2TestShapeInputService2TestCaseOperation1Output, error) { req, out := c.InputService2TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService2TestShapeInputService2TestCaseOperation1Input struct { _ struct{} `type:"structure"` TimeArg time.Time `type:"timestamp"` TimeCustom time.Time `type:"timestamp" timestampFormat:"rfc822"` TimeFormat time.Time `type:"timestamp" timestampFormat:"rfc822"` } // SetTimeArg sets the TimeArg field's value. func (s InputService2TestShapeInputService2TestCaseOperation1Input) SetTimeArg(v time.Time) InputService2TestShapeInputService2TestCaseOperation1Input { s.TimeArg = &v return s } // SetTimeCustom sets the TimeCustom field's value. func (s InputService2TestShapeInputService2TestCaseOperation1Input) SetTimeCustom(v time.Time) InputService2TestShapeInputService2TestCaseOperation1Input { s.TimeCustom = &v return s } // SetTimeFormat sets the TimeFormat field's value. func (s InputService2TestShapeInputService2TestCaseOperation1Input) SetTimeFormat(v time.Time) InputService2TestShapeInputService2TestCaseOperation1Input { s.TimeFormat = &v return s } type InputService2TestShapeInputService2TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // InputService3ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService3ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService3ProtocolTest struct { client.Client } // New creates a new instance of the InputService3ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a InputService3ProtocolTest client from just a session. // svc := inputservice3protocoltest.New(mySession) // // // Create a InputService3ProtocolTest client with additional configuration // svc := inputservice3protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService3ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService3ProtocolTest { c := p.ClientConfig("inputservice3protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService3ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService3ProtocolTest { svc := &InputService3ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService3ProtocolTest", ServiceID: "InputService3ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, JSONVersion: "1.1", TargetPrefix: "com.amazonaws.foo", }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // 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 "aws/request.Request" representing the // client's request for the InputService3TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService3TestCaseOperation1 for more information on using the InputService3TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService3TestCaseOperation1Request method. // req, resp := client.InputService3TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService3ProtocolTest) InputService3TestCaseOperation1Request(input InputService3TestShapeInputService3TestCaseOperation1Input) (req request.Request, output InputService3TestShapeInputService3TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService3TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &InputService3TestShapeInputService3TestCaseOperation1Input{} } output = &InputService3TestShapeInputService3TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService3TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService3TestCaseOperation1 for usage and error information. func (c InputService3ProtocolTest) InputService3TestCaseOperation1(input InputService3TestShapeInputService3TestCaseOperation1Input) (InputService3TestShapeInputService3TestCaseOperation1Output, error) { req, out := c.InputService3TestCaseOperation1Request(input) return out, req.Send() } // InputService3TestCaseOperation1WithContext is the same as InputService3TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService3TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService3ProtocolTest) InputService3TestCaseOperation1WithContext(ctx aws.Context, input InputService3TestShapeInputService3TestCaseOperation1Input, opts ...request.Option) (InputService3TestShapeInputService3TestCaseOperation1Output, error) { req, out := c.InputService3TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService3TestCaseOperation2 = "OperationName" // InputService3TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the InputService3TestCaseOperation2 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService3TestCaseOperation2 for more information on using the InputService3TestCaseOperation2 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService3TestCaseOperation2Request method. // req, resp := client.InputService3TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService3ProtocolTest) InputService3TestCaseOperation2Request(input InputService3TestShapeInputService3TestCaseOperation2Input) (req request.Request, output InputService3TestShapeInputService3TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService3TestCaseOperation2, HTTPPath: "/", } if input == nil { input = &InputService3TestShapeInputService3TestCaseOperation2Input{} } output = &InputService3TestShapeInputService3TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService3TestCaseOperation2 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService3TestCaseOperation2 for usage and error information. func (c InputService3ProtocolTest) InputService3TestCaseOperation2(input InputService3TestShapeInputService3TestCaseOperation2Input) (InputService3TestShapeInputService3TestCaseOperation2Output, error) { req, out := c.InputService3TestCaseOperation2Request(input) return out, req.Send() } // InputService3TestCaseOperation2WithContext is the same as InputService3TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See InputService3TestCaseOperation2 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService3ProtocolTest) InputService3TestCaseOperation2WithContext(ctx aws.Context, input InputService3TestShapeInputService3TestCaseOperation2Input, opts ...request.Option) (InputService3TestShapeInputService3TestCaseOperation2Output, error) { req, out := c.InputService3TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService3TestShapeInputService3TestCaseOperation1Input struct { _ struct{} `type:"structure"` // BlobArg is automatically base64 encoded/decoded by the SDK. BlobArg []byte `type:"blob"` BlobMap map[string][]byte `type:"map"` } // SetBlobArg sets the BlobArg field's value. func (s InputService3TestShapeInputService3TestCaseOperation1Input) SetBlobArg(v []byte) InputService3TestShapeInputService3TestCaseOperation1Input { s.BlobArg = v return s } // SetBlobMap sets the BlobMap field's value. func (s InputService3TestShapeInputService3TestCaseOperation1Input) SetBlobMap(v map[string][]byte) InputService3TestShapeInputService3TestCaseOperation1Input { s.BlobMap = v return s } type InputService3TestShapeInputService3TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService3TestShapeInputService3TestCaseOperation2Input struct { _ struct{} `type:"structure"` // BlobArg is automatically base64 encoded/decoded by the SDK. BlobArg []byte `type:"blob"` BlobMap map[string][]byte `type:"map"` } // SetBlobArg sets the BlobArg field's value. func (s InputService3TestShapeInputService3TestCaseOperation2Input) SetBlobArg(v []byte) InputService3TestShapeInputService3TestCaseOperation2Input { s.BlobArg = v return s } // SetBlobMap sets the BlobMap field's value. func (s InputService3TestShapeInputService3TestCaseOperation2Input) SetBlobMap(v map[string][]byte) InputService3TestShapeInputService3TestCaseOperation2Input { s.BlobMap = v return s } type InputService3TestShapeInputService3TestCaseOperation2Output struct { _ struct{} `type:"structure"` } // InputService4ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService4ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService4ProtocolTest struct { client.Client } // New creates a new instance of the InputService4ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a InputService4ProtocolTest client from just a session. // svc := inputservice4protocoltest.New(mySession) // // // Create a InputService4ProtocolTest client with additional configuration // svc := inputservice4protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService4ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService4ProtocolTest { c := p.ClientConfig("inputservice4protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService4ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService4ProtocolTest { svc := &InputService4ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService4ProtocolTest", ServiceID: "InputService4ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, JSONVersion: "1.1", TargetPrefix: "com.amazonaws.foo", }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // 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 "aws/request.Request" representing the // client's request for the InputService4TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService4TestCaseOperation1 for more information on using the InputService4TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService4TestCaseOperation1Request method. // req, resp := client.InputService4TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService4ProtocolTest) InputService4TestCaseOperation1Request(input InputService4TestShapeInputService4TestCaseOperation1Input) (req request.Request, output InputService4TestShapeInputService4TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService4TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService4TestShapeInputService4TestCaseOperation1Input{} } output = &InputService4TestShapeInputService4TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService4TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService4TestCaseOperation1 for usage and error information. func (c InputService4ProtocolTest) InputService4TestCaseOperation1(input InputService4TestShapeInputService4TestCaseOperation1Input) (InputService4TestShapeInputService4TestCaseOperation1Output, error) { req, out := c.InputService4TestCaseOperation1Request(input) return out, req.Send() } // InputService4TestCaseOperation1WithContext is the same as InputService4TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService4TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService4ProtocolTest) InputService4TestCaseOperation1WithContext(ctx aws.Context, input InputService4TestShapeInputService4TestCaseOperation1Input, opts ...request.Option) (InputService4TestShapeInputService4TestCaseOperation1Output, error) { req, out := c.InputService4TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService4TestShapeInputService4TestCaseOperation1Input struct { _ struct{} `type:"structure"` ListParam [][]byte `type:"list"` } // SetListParam sets the ListParam field's value. func (s InputService4TestShapeInputService4TestCaseOperation1Input) SetListParam(v [][]byte) InputService4TestShapeInputService4TestCaseOperation1Input { s.ListParam = v return s } type InputService4TestShapeInputService4TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // InputService5ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService5ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService5ProtocolTest struct { client.Client } // New creates a new instance of the InputService5ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a InputService5ProtocolTest client from just a session. // svc := inputservice5protocoltest.New(mySession) // // // Create a InputService5ProtocolTest client with additional configuration // svc := inputservice5protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService5ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService5ProtocolTest { c := p.ClientConfig("inputservice5protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService5ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService5ProtocolTest { svc := &InputService5ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService5ProtocolTest", ServiceID: "InputService5ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, JSONVersion: "1.1", TargetPrefix: "com.amazonaws.foo", }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // 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 "aws/request.Request" representing the // client's request for the InputService5TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService5TestCaseOperation1 for more information on using the InputService5TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService5TestCaseOperation1Request method. // req, resp := client.InputService5TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService5ProtocolTest) InputService5TestCaseOperation1Request(input InputService5TestShapeInputService5TestCaseOperation1Input) (req request.Request, output InputService5TestShapeInputService5TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService5TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &InputService5TestShapeInputService5TestCaseOperation1Input{} } output = &InputService5TestShapeInputService5TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService5TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService5TestCaseOperation1 for usage and error information. func (c InputService5ProtocolTest) InputService5TestCaseOperation1(input InputService5TestShapeInputService5TestCaseOperation1Input) (InputService5TestShapeInputService5TestCaseOperation1Output, error) { req, out := c.InputService5TestCaseOperation1Request(input) return out, req.Send() } // InputService5TestCaseOperation1WithContext is the same as InputService5TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService5TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService5ProtocolTest) InputService5TestCaseOperation1WithContext(ctx aws.Context, input InputService5TestShapeInputService5TestCaseOperation1Input, opts ...request.Option) (InputService5TestShapeInputService5TestCaseOperation1Output, error) { req, out := c.InputService5TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService5TestCaseOperation2 = "OperationName" // InputService5TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the InputService5TestCaseOperation2 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService5TestCaseOperation2 for more information on using the InputService5TestCaseOperation2 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService5TestCaseOperation2Request method. // req, resp := client.InputService5TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService5ProtocolTest) InputService5TestCaseOperation2Request(input InputService5TestShapeInputService5TestCaseOperation2Input) (req request.Request, output InputService5TestShapeInputService5TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService5TestCaseOperation2, HTTPPath: "/", } if input == nil { input = &InputService5TestShapeInputService5TestCaseOperation2Input{} } output = &InputService5TestShapeInputService5TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService5TestCaseOperation2 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService5TestCaseOperation2 for usage and error information. func (c InputService5ProtocolTest) InputService5TestCaseOperation2(input InputService5TestShapeInputService5TestCaseOperation2Input) (InputService5TestShapeInputService5TestCaseOperation2Output, error) { req, out := c.InputService5TestCaseOperation2Request(input) return out, req.Send() } // InputService5TestCaseOperation2WithContext is the same as InputService5TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See InputService5TestCaseOperation2 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService5ProtocolTest) InputService5TestCaseOperation2WithContext(ctx aws.Context, input InputService5TestShapeInputService5TestCaseOperation2Input, opts ...request.Option) (InputService5TestShapeInputService5TestCaseOperation2Output, error) { req, out := c.InputService5TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService5TestCaseOperation3 = "OperationName" // InputService5TestCaseOperation3Request generates a "aws/request.Request" representing the // client's request for the InputService5TestCaseOperation3 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService5TestCaseOperation3 for more information on using the InputService5TestCaseOperation3 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService5TestCaseOperation3Request method. // req, resp := client.InputService5TestCaseOperation3Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService5ProtocolTest) InputService5TestCaseOperation3Request(input InputService5TestShapeInputService5TestCaseOperation3Input) (req request.Request, output InputService5TestShapeInputService5TestCaseOperation3Output) { op := &request.Operation{ Name: opInputService5TestCaseOperation3, HTTPPath: "/", } if input == nil { input = &InputService5TestShapeInputService5TestCaseOperation3Input{} } output = &InputService5TestShapeInputService5TestCaseOperation3Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService5TestCaseOperation3 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService5TestCaseOperation3 for usage and error information. func (c InputService5ProtocolTest) InputService5TestCaseOperation3(input InputService5TestShapeInputService5TestCaseOperation3Input) (InputService5TestShapeInputService5TestCaseOperation3Output, error) { req, out := c.InputService5TestCaseOperation3Request(input) return out, req.Send() } // InputService5TestCaseOperation3WithContext is the same as InputService5TestCaseOperation3 with the addition of // the ability to pass a context and additional request options. // // See InputService5TestCaseOperation3 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService5ProtocolTest) InputService5TestCaseOperation3WithContext(ctx aws.Context, input InputService5TestShapeInputService5TestCaseOperation3Input, opts ...request.Option) (InputService5TestShapeInputService5TestCaseOperation3Output, error) { req, out := c.InputService5TestCaseOperation3Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService5TestCaseOperation4 = "OperationName" // InputService5TestCaseOperation4Request generates a "aws/request.Request" representing the // client's request for the InputService5TestCaseOperation4 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService5TestCaseOperation4 for more information on using the InputService5TestCaseOperation4 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService5TestCaseOperation4Request method. // req, resp := client.InputService5TestCaseOperation4Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService5ProtocolTest) InputService5TestCaseOperation4Request(input InputService5TestShapeInputService5TestCaseOperation4Input) (req request.Request, output InputService5TestShapeInputService5TestCaseOperation4Output) { op := &request.Operation{ Name: opInputService5TestCaseOperation4, HTTPPath: "/", } if input == nil { input = &InputService5TestShapeInputService5TestCaseOperation4Input{} } output = &InputService5TestShapeInputService5TestCaseOperation4Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService5TestCaseOperation4 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService5TestCaseOperation4 for usage and error information. func (c InputService5ProtocolTest) InputService5TestCaseOperation4(input InputService5TestShapeInputService5TestCaseOperation4Input) (InputService5TestShapeInputService5TestCaseOperation4Output, error) { req, out := c.InputService5TestCaseOperation4Request(input) return out, req.Send() } // InputService5TestCaseOperation4WithContext is the same as InputService5TestCaseOperation4 with the addition of // the ability to pass a context and additional request options. // // See InputService5TestCaseOperation4 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService5ProtocolTest) InputService5TestCaseOperation4WithContext(ctx aws.Context, input InputService5TestShapeInputService5TestCaseOperation4Input, opts ...request.Option) (InputService5TestShapeInputService5TestCaseOperation4Output, error) { req, out := c.InputService5TestCaseOperation4Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService5TestCaseOperation5 = "OperationName" // InputService5TestCaseOperation5Request generates a "aws/request.Request" representing the // client's request for the InputService5TestCaseOperation5 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService5TestCaseOperation5 for more information on using the InputService5TestCaseOperation5 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService5TestCaseOperation5Request method. // req, resp := client.InputService5TestCaseOperation5Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService5ProtocolTest) InputService5TestCaseOperation5Request(input InputService5TestShapeInputService5TestCaseOperation5Input) (req request.Request, output InputService5TestShapeInputService5TestCaseOperation5Output) { op := &request.Operation{ Name: opInputService5TestCaseOperation5, HTTPPath: "/", } if input == nil { input = &InputService5TestShapeInputService5TestCaseOperation5Input{} } output = &InputService5TestShapeInputService5TestCaseOperation5Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService5TestCaseOperation5 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService5TestCaseOperation5 for usage and error information. func (c InputService5ProtocolTest) InputService5TestCaseOperation5(input InputService5TestShapeInputService5TestCaseOperation5Input) (InputService5TestShapeInputService5TestCaseOperation5Output, error) { req, out := c.InputService5TestCaseOperation5Request(input) return out, req.Send() } // InputService5TestCaseOperation5WithContext is the same as InputService5TestCaseOperation5 with the addition of // the ability to pass a context and additional request options. // // See InputService5TestCaseOperation5 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService5ProtocolTest) InputService5TestCaseOperation5WithContext(ctx aws.Context, input InputService5TestShapeInputService5TestCaseOperation5Input, opts ...request.Option) (InputService5TestShapeInputService5TestCaseOperation5Output, error) { req, out := c.InputService5TestCaseOperation5Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService5TestCaseOperation6 = "OperationName" // InputService5TestCaseOperation6Request generates a "aws/request.Request" representing the // client's request for the InputService5TestCaseOperation6 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService5TestCaseOperation6 for more information on using the InputService5TestCaseOperation6 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService5TestCaseOperation6Request method. // req, resp := client.InputService5TestCaseOperation6Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService5ProtocolTest) InputService5TestCaseOperation6Request(input InputService5TestShapeInputService5TestCaseOperation6Input) (req request.Request, output InputService5TestShapeInputService5TestCaseOperation6Output) { op := &request.Operation{ Name: opInputService5TestCaseOperation6, HTTPPath: "/", } if input == nil { input = &InputService5TestShapeInputService5TestCaseOperation6Input{} } output = &InputService5TestShapeInputService5TestCaseOperation6Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService5TestCaseOperation6 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService5TestCaseOperation6 for usage and error information. func (c InputService5ProtocolTest) InputService5TestCaseOperation6(input InputService5TestShapeInputService5TestCaseOperation6Input) (InputService5TestShapeInputService5TestCaseOperation6Output, error) { req, out := c.InputService5TestCaseOperation6Request(input) return out, req.Send() } // InputService5TestCaseOperation6WithContext is the same as InputService5TestCaseOperation6 with the addition of // the ability to pass a context and additional request options. // // See InputService5TestCaseOperation6 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService5ProtocolTest) InputService5TestCaseOperation6WithContext(ctx aws.Context, input InputService5TestShapeInputService5TestCaseOperation6Input, opts ...request.Option) (InputService5TestShapeInputService5TestCaseOperation6Output, error) { req, out := c.InputService5TestCaseOperation6Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService5TestShapeInputService5TestCaseOperation1Input struct { _ struct{} `type:"structure"` RecursiveStruct InputService5TestShapeRecursiveStructType `type:"structure"` } // SetRecursiveStruct sets the RecursiveStruct field's value. func (s InputService5TestShapeInputService5TestCaseOperation1Input) SetRecursiveStruct(v InputService5TestShapeRecursiveStructType) InputService5TestShapeInputService5TestCaseOperation1Input { s.RecursiveStruct = v return s } type InputService5TestShapeInputService5TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService5TestShapeInputService5TestCaseOperation2Input struct { _ struct{} `type:"structure"` RecursiveStruct InputService5TestShapeRecursiveStructType `type:"structure"` } // SetRecursiveStruct sets the RecursiveStruct field's value. func (s InputService5TestShapeInputService5TestCaseOperation2Input) SetRecursiveStruct(v InputService5TestShapeRecursiveStructType) InputService5TestShapeInputService5TestCaseOperation2Input { s.RecursiveStruct = v return s } type InputService5TestShapeInputService5TestCaseOperation2Output struct { _ struct{} `type:"structure"` } type InputService5TestShapeInputService5TestCaseOperation3Input struct { _ struct{} `type:"structure"` RecursiveStruct InputService5TestShapeRecursiveStructType `type:"structure"` } // SetRecursiveStruct sets the RecursiveStruct field's value. func (s InputService5TestShapeInputService5TestCaseOperation3Input) SetRecursiveStruct(v InputService5TestShapeRecursiveStructType) InputService5TestShapeInputService5TestCaseOperation3Input { s.RecursiveStruct = v return s } type InputService5TestShapeInputService5TestCaseOperation3Output struct { _ struct{} `type:"structure"` } type InputService5TestShapeInputService5TestCaseOperation4Input struct { _ struct{} `type:"structure"` RecursiveStruct InputService5TestShapeRecursiveStructType `type:"structure"` } // SetRecursiveStruct sets the RecursiveStruct field's value. func (s InputService5TestShapeInputService5TestCaseOperation4Input) SetRecursiveStruct(v InputService5TestShapeRecursiveStructType) InputService5TestShapeInputService5TestCaseOperation4Input { s.RecursiveStruct = v return s } type InputService5TestShapeInputService5TestCaseOperation4Output struct { _ struct{} `type:"structure"` } type InputService5TestShapeInputService5TestCaseOperation5Input struct { _ struct{} `type:"structure"` RecursiveStruct InputService5TestShapeRecursiveStructType `type:"structure"` } // SetRecursiveStruct sets the RecursiveStruct field's value. func (s InputService5TestShapeInputService5TestCaseOperation5Input) SetRecursiveStruct(v InputService5TestShapeRecursiveStructType) InputService5TestShapeInputService5TestCaseOperation5Input { s.RecursiveStruct = v return s } type InputService5TestShapeInputService5TestCaseOperation5Output struct { _ struct{} `type:"structure"` } type InputService5TestShapeInputService5TestCaseOperation6Input struct { _ struct{} `type:"structure"` RecursiveStruct InputService5TestShapeRecursiveStructType `type:"structure"` } // SetRecursiveStruct sets the RecursiveStruct field's value. func (s InputService5TestShapeInputService5TestCaseOperation6Input) SetRecursiveStruct(v InputService5TestShapeRecursiveStructType) InputService5TestShapeInputService5TestCaseOperation6Input { s.RecursiveStruct = v return s } type InputService5TestShapeInputService5TestCaseOperation6Output struct { _ struct{} `type:"structure"` } type InputService5TestShapeRecursiveStructType struct { _ struct{} `type:"structure"` NoRecurse string `type:"string"` RecursiveList []InputService5TestShapeRecursiveStructType `type:"list"` RecursiveMap map[string]InputService5TestShapeRecursiveStructType `type:"map"` RecursiveStruct InputService5TestShapeRecursiveStructType `type:"structure"` } // SetNoRecurse sets the NoRecurse field's value. func (s InputService5TestShapeRecursiveStructType) SetNoRecurse(v string) InputService5TestShapeRecursiveStructType { s.NoRecurse = &v return s } // SetRecursiveList sets the RecursiveList field's value. func (s InputService5TestShapeRecursiveStructType) SetRecursiveList(v []InputService5TestShapeRecursiveStructType) InputService5TestShapeRecursiveStructType { s.RecursiveList = v return s } // SetRecursiveMap sets the RecursiveMap field's value. func (s InputService5TestShapeRecursiveStructType) SetRecursiveMap(v map[string]InputService5TestShapeRecursiveStructType) InputService5TestShapeRecursiveStructType { s.RecursiveMap = v return s } // SetRecursiveStruct sets the RecursiveStruct field's value. func (s InputService5TestShapeRecursiveStructType) SetRecursiveStruct(v InputService5TestShapeRecursiveStructType) InputService5TestShapeRecursiveStructType { s.RecursiveStruct = v return s } // InputService6ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService6ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService6ProtocolTest struct { client.Client } // New creates a new instance of the InputService6ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a InputService6ProtocolTest client from just a session. // svc := inputservice6protocoltest.New(mySession) // // // Create a InputService6ProtocolTest client with additional configuration // svc := inputservice6protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService6ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService6ProtocolTest { c := p.ClientConfig("inputservice6protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService6ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService6ProtocolTest { svc := &InputService6ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService6ProtocolTest", ServiceID: "InputService6ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, JSONVersion: "1.1", TargetPrefix: "com.amazonaws.foo", }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // 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 "aws/request.Request" representing the // client's request for the InputService6TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService6TestCaseOperation1 for more information on using the InputService6TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService6TestCaseOperation1Request method. // req, resp := client.InputService6TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService6ProtocolTest) InputService6TestCaseOperation1Request(input InputService6TestShapeInputService6TestCaseOperation1Input) (req request.Request, output InputService6TestShapeInputService6TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService6TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService6TestShapeInputService6TestCaseOperation1Input{} } output = &InputService6TestShapeInputService6TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService6TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService6TestCaseOperation1 for usage and error information. func (c InputService6ProtocolTest) InputService6TestCaseOperation1(input InputService6TestShapeInputService6TestCaseOperation1Input) (InputService6TestShapeInputService6TestCaseOperation1Output, error) { req, out := c.InputService6TestCaseOperation1Request(input) return out, req.Send() } // InputService6TestCaseOperation1WithContext is the same as InputService6TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService6TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService6ProtocolTest) InputService6TestCaseOperation1WithContext(ctx aws.Context, input InputService6TestShapeInputService6TestCaseOperation1Input, opts ...request.Option) (InputService6TestShapeInputService6TestCaseOperation1Output, error) { req, out := c.InputService6TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService6TestShapeInputService6TestCaseOperation1Input struct { _ struct{} `type:"structure"` Map map[string]string `type:"map"` } // SetMap sets the Map field's value. func (s InputService6TestShapeInputService6TestCaseOperation1Input) SetMap(v map[string]string) InputService6TestShapeInputService6TestCaseOperation1Input { s.Map = v return s } type InputService6TestShapeInputService6TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // InputService7ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService7ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService7ProtocolTest struct { client.Client } // New creates a new instance of the InputService7ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a InputService7ProtocolTest client from just a session. // svc := inputservice7protocoltest.New(mySession) // // // Create a InputService7ProtocolTest client with additional configuration // svc := inputservice7protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService7ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService7ProtocolTest { c := p.ClientConfig("inputservice7protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService7ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService7ProtocolTest { svc := &InputService7ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService7ProtocolTest", ServiceID: "InputService7ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "2014-01-01", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // 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 "aws/request.Request" representing the // client's request for the InputService7TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService7TestCaseOperation1 for more information on using the InputService7TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService7TestCaseOperation1Request method. // req, resp := client.InputService7TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService7ProtocolTest) InputService7TestCaseOperation1Request(input InputService7TestShapeInputService7TestCaseOperation1Input) (req request.Request, output InputService7TestShapeInputService7TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService7TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService7TestShapeInputService7TestCaseOperation1Input{} } output = &InputService7TestShapeInputService7TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService7TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService7TestCaseOperation1 for usage and error information. func (c InputService7ProtocolTest) InputService7TestCaseOperation1(input InputService7TestShapeInputService7TestCaseOperation1Input) (InputService7TestShapeInputService7TestCaseOperation1Output, error) { req, out := c.InputService7TestCaseOperation1Request(input) return out, req.Send() } // InputService7TestCaseOperation1WithContext is the same as InputService7TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService7TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService7ProtocolTest) InputService7TestCaseOperation1WithContext(ctx aws.Context, input InputService7TestShapeInputService7TestCaseOperation1Input, opts ...request.Option) (InputService7TestShapeInputService7TestCaseOperation1Output, error) { req, out := c.InputService7TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService7TestCaseOperation2 = "OperationName" // InputService7TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the InputService7TestCaseOperation2 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService7TestCaseOperation2 for more information on using the InputService7TestCaseOperation2 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService7TestCaseOperation2Request method. // req, resp := client.InputService7TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService7ProtocolTest) InputService7TestCaseOperation2Request(input InputService7TestShapeInputService7TestCaseOperation2Input) (req request.Request, output InputService7TestShapeInputService7TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService7TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService7TestShapeInputService7TestCaseOperation2Input{} } output = &InputService7TestShapeInputService7TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService7TestCaseOperation2 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService7TestCaseOperation2 for usage and error information. func (c InputService7ProtocolTest) InputService7TestCaseOperation2(input InputService7TestShapeInputService7TestCaseOperation2Input) (InputService7TestShapeInputService7TestCaseOperation2Output, error) { req, out := c.InputService7TestCaseOperation2Request(input) return out, req.Send() } // InputService7TestCaseOperation2WithContext is the same as InputService7TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See InputService7TestCaseOperation2 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService7ProtocolTest) InputService7TestCaseOperation2WithContext(ctx aws.Context, input InputService7TestShapeInputService7TestCaseOperation2Input, opts ...request.Option) (InputService7TestShapeInputService7TestCaseOperation2Output, error) { req, out := c.InputService7TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService7TestShapeInputService7TestCaseOperation1Input struct { _ struct{} `type:"structure"` Token string `type:"string" idempotencyToken:"true"` } // SetToken sets the Token field's value. func (s InputService7TestShapeInputService7TestCaseOperation1Input) SetToken(v string) InputService7TestShapeInputService7TestCaseOperation1Input { s.Token = &v return s } type InputService7TestShapeInputService7TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService7TestShapeInputService7TestCaseOperation2Input struct { _ struct{} `type:"structure"` Token string `type:"string" idempotencyToken:"true"` } // SetToken sets the Token field's value. func (s InputService7TestShapeInputService7TestCaseOperation2Input) SetToken(v string) InputService7TestShapeInputService7TestCaseOperation2Input { s.Token = &v return s } type InputService7TestShapeInputService7TestCaseOperation2Output struct { _ struct{} `type:"structure"` } // InputService8ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService8ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService8ProtocolTest struct { client.Client } // New creates a new instance of the InputService8ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a InputService8ProtocolTest client from just a session. // svc := inputservice8protocoltest.New(mySession) // // // Create a InputService8ProtocolTest client with additional configuration // svc := inputservice8protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService8ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService8ProtocolTest { c := p.ClientConfig("inputservice8protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService8ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService8ProtocolTest { svc := &InputService8ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService8ProtocolTest", ServiceID: "InputService8ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "2014-01-01", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // 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 "aws/request.Request" representing the // client's request for the InputService8TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService8TestCaseOperation1 for more information on using the InputService8TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService8TestCaseOperation1Request method. // req, resp := client.InputService8TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService8ProtocolTest) InputService8TestCaseOperation1Request(input InputService8TestShapeInputService8TestCaseOperation1Input) (req request.Request, output InputService8TestShapeInputService8TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService8TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService8TestShapeInputService8TestCaseOperation1Input{} } output = &InputService8TestShapeInputService8TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService8TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService8TestCaseOperation1 for usage and error information. func (c InputService8ProtocolTest) InputService8TestCaseOperation1(input InputService8TestShapeInputService8TestCaseOperation1Input) (InputService8TestShapeInputService8TestCaseOperation1Output, error) { req, out := c.InputService8TestCaseOperation1Request(input) return out, req.Send() } // InputService8TestCaseOperation1WithContext is the same as InputService8TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService8TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService8ProtocolTest) InputService8TestCaseOperation1WithContext(ctx aws.Context, input InputService8TestShapeInputService8TestCaseOperation1Input, opts ...request.Option) (InputService8TestShapeInputService8TestCaseOperation1Output, error) { req, out := c.InputService8TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService8TestCaseOperation2 = "OperationName" // InputService8TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the InputService8TestCaseOperation2 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService8TestCaseOperation2 for more information on using the InputService8TestCaseOperation2 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService8TestCaseOperation2Request method. // req, resp := client.InputService8TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService8ProtocolTest) InputService8TestCaseOperation2Request(input InputService8TestShapeInputService8TestCaseOperation2Input) (req request.Request, output InputService8TestShapeInputService8TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService8TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService8TestShapeInputService8TestCaseOperation2Input{} } output = &InputService8TestShapeInputService8TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService8TestCaseOperation2 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService8TestCaseOperation2 for usage and error information. func (c InputService8ProtocolTest) InputService8TestCaseOperation2(input InputService8TestShapeInputService8TestCaseOperation2Input) (InputService8TestShapeInputService8TestCaseOperation2Output, error) { req, out := c.InputService8TestCaseOperation2Request(input) return out, req.Send() } // InputService8TestCaseOperation2WithContext is the same as InputService8TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See InputService8TestCaseOperation2 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService8ProtocolTest) InputService8TestCaseOperation2WithContext(ctx aws.Context, input InputService8TestShapeInputService8TestCaseOperation2Input, opts ...request.Option) (InputService8TestShapeInputService8TestCaseOperation2Output, error) { req, out := c.InputService8TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService8TestShapeInputService8TestCaseOperation1Input struct { _ struct{} `type:"structure"` FooEnum string `type:"string" enum:"InputService8TestShapeEnumType"` ListEnums []string `type:"list" enum:"InputService8TestShapeEnumType"` } // SetFooEnum sets the FooEnum field's value. func (s InputService8TestShapeInputService8TestCaseOperation1Input) SetFooEnum(v string) InputService8TestShapeInputService8TestCaseOperation1Input { s.FooEnum = &v return s } // SetListEnums sets the ListEnums field's value. func (s InputService8TestShapeInputService8TestCaseOperation1Input) SetListEnums(v []string) InputService8TestShapeInputService8TestCaseOperation1Input { s.ListEnums = v return s } type InputService8TestShapeInputService8TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService8TestShapeInputService8TestCaseOperation2Input struct { _ struct{} `type:"structure"` FooEnum string `type:"string" enum:"InputService8TestShapeEnumType"` ListEnums []string `type:"list" enum:"InputService8TestShapeEnumType"` } // SetFooEnum sets the FooEnum field's value. func (s InputService8TestShapeInputService8TestCaseOperation2Input) SetFooEnum(v string) InputService8TestShapeInputService8TestCaseOperation2Input { s.FooEnum = &v return s } // SetListEnums sets the ListEnums field's value. func (s InputService8TestShapeInputService8TestCaseOperation2Input) SetListEnums(v []string) InputService8TestShapeInputService8TestCaseOperation2Input { s.ListEnums = v return s } type InputService8TestShapeInputService8TestCaseOperation2Output struct { _ struct{} `type:"structure"` } const ( // EnumTypeFoo is a InputService8TestShapeEnumType enum value EnumTypeFoo = "foo" // EnumTypeBar is a InputService8TestShapeEnumType enum value EnumTypeBar = "bar" ) // InputService8TestShapeEnumType_Values returns all elements of the InputService8TestShapeEnumType enum func InputService8TestShapeEnumType_Values() []string { return []string{ EnumTypeFoo, EnumTypeBar, } } // InputService9ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService9ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService9ProtocolTest struct { client.Client } // New creates a new instance of the InputService9ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a InputService9ProtocolTest client from just a session. // svc := inputservice9protocoltest.New(mySession) // // // Create a InputService9ProtocolTest client with additional configuration // svc := inputservice9protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService9ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService9ProtocolTest { c := p.ClientConfig("inputservice9protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService9ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService9ProtocolTest { svc := &InputService9ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService9ProtocolTest", ServiceID: "InputService9ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, JSONVersion: "1.1", TargetPrefix: "com.amazonaws.foo", }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // 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 = "StaticOp" // InputService9TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService9TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService9TestCaseOperation1 for more information on using the InputService9TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService9TestCaseOperation1Request method. // req, resp := client.InputService9TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService9ProtocolTest) InputService9TestCaseOperation1Request(input InputService9TestShapeInputService9TestCaseOperation1Input) (req request.Request, output InputService9TestShapeInputService9TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService9TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService9TestShapeInputService9TestCaseOperation1Input{} } output = &InputService9TestShapeInputService9TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) req.Handlers.Build.PushBackNamed(protocol.NewHostPrefixHandler("data-", nil)) req.Handlers.Build.PushBackNamed(protocol.ValidateEndpointHostHandler) return } // InputService9TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService9TestCaseOperation1 for usage and error information. func (c InputService9ProtocolTest) InputService9TestCaseOperation1(input InputService9TestShapeInputService9TestCaseOperation1Input) (InputService9TestShapeInputService9TestCaseOperation1Output, error) { req, out := c.InputService9TestCaseOperation1Request(input) return out, req.Send() } // InputService9TestCaseOperation1WithContext is the same as InputService9TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService9TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService9ProtocolTest) InputService9TestCaseOperation1WithContext(ctx aws.Context, input InputService9TestShapeInputService9TestCaseOperation1Input, opts ...request.Option) (InputService9TestShapeInputService9TestCaseOperation1Output, error) { req, out := c.InputService9TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService9TestCaseOperation2 = "MemberRefOp" // InputService9TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the InputService9TestCaseOperation2 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See InputService9TestCaseOperation2 for more information on using the InputService9TestCaseOperation2 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the InputService9TestCaseOperation2Request method. // req, resp := client.InputService9TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService9ProtocolTest) InputService9TestCaseOperation2Request(input InputService9TestShapeInputService9TestCaseOperation2Input) (req request.Request, output InputService9TestShapeInputService9TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService9TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService9TestShapeInputService9TestCaseOperation2Input{} } output = &InputService9TestShapeInputService9TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) req.Handlers.Build.PushBackNamed(protocol.NewHostPrefixHandler("foo-{Name}.", input.hostLabels)) req.Handlers.Build.PushBackNamed(protocol.ValidateEndpointHostHandler) return } // InputService9TestCaseOperation2 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation InputService9TestCaseOperation2 for usage and error information. func (c InputService9ProtocolTest) InputService9TestCaseOperation2(input InputService9TestShapeInputService9TestCaseOperation2Input) (InputService9TestShapeInputService9TestCaseOperation2Output, error) { req, out := c.InputService9TestCaseOperation2Request(input) return out, req.Send() } // InputService9TestCaseOperation2WithContext is the same as InputService9TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See InputService9TestCaseOperation2 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c InputService9ProtocolTest) InputService9TestCaseOperation2WithContext(ctx aws.Context, input InputService9TestShapeInputService9TestCaseOperation2Input, opts ...request.Option) (InputService9TestShapeInputService9TestCaseOperation2Output, error) { req, out := c.InputService9TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService9TestShapeInputService9TestCaseOperation1Input struct { _ struct{} `type:"structure"` Name string `type:"string"` } // SetName sets the Name field's value. func (s InputService9TestShapeInputService9TestCaseOperation1Input) SetName(v string) InputService9TestShapeInputService9TestCaseOperation1Input { s.Name = &v return s } type InputService9TestShapeInputService9TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService9TestShapeInputService9TestCaseOperation2Input struct { _ struct{} `type:"structure"` // Name is a required field Name string `type:"string" required:"true"` } // Validate inspects the fields of the type to determine if they are valid. func (s InputService9TestShapeInputService9TestCaseOperation2Input) Validate() error { invalidParams := request.ErrInvalidParams{Context: "InputService9TestShapeInputService9TestCaseOperation2Input"} if s.Name == nil { invalidParams.Add(request.NewErrParamRequired("Name")) } if s.Name != nil && len(s.Name) < 1 { invalidParams.Add(request.NewErrParamMinLen("Name", 1)) } if invalidParams.Len() > 0 { return invalidParams } return nil } // SetName sets the Name field's value. func (s InputService9TestShapeInputService9TestCaseOperation2Input) SetName(v string) InputService9TestShapeInputService9TestCaseOperation2Input { s.Name = &v return s } func (s InputService9TestShapeInputService9TestCaseOperation2Input) hostLabels() map[string]string { return map[string]string{ "Name": aws.StringValue(s.Name), } } type InputService9TestShapeInputService9TestCaseOperation2Output struct { _ struct{} `type:"structure"` } // // Tests begin here // func TestInputService1ProtocolTestScalarMembersCase1(t testing.T) { svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService1TestShapeInputService1TestCaseOperation1Input{ Name: aws.String("myname"), } req, _ := svc.InputService1TestCaseOperation1Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"Name": "myname"}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers if e, a := "application/x-amz-json-1.1", r.Header.Get("Content-Type"); e != a { t.Errorf("expect Content-Type %v header value, got %v", e, a) } if e, a := "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target"); e != a { t.Errorf("expect X-Amz-Target %v header value, got %v", e, a) } } func TestInputService2ProtocolTestTimestampValuesCase1(t testing.T) { svc := NewInputService2ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService2TestShapeInputService2TestCaseOperation1Input{ TimeArg: aws.Time(time.Unix(1422172800, 0)), TimeCustom: aws.Time(time.Unix(1422172800, 0)), TimeFormat: aws.Time(time.Unix(1422172800, 0)), } req, _ := svc.InputService2TestCaseOperation1Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"TimeArg": 1422172800, "TimeCustom": "Sun, 25 Jan 2015 08:00:00 GMT", "TimeFormat": "Sun, 25 Jan 2015 08:00:00 GMT"}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers if e, a := "application/x-amz-json-1.1", r.Header.Get("Content-Type"); e != a { t.Errorf("expect Content-Type %v header value, got %v", e, a) } if e, a := "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target"); e != a { t.Errorf("expect X-Amz-Target %v header value, got %v", e, a) } } func TestInputService3ProtocolTestBase64EncodedBlobsCase1(t testing.T) { svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService3TestShapeInputService3TestCaseOperation1Input{ BlobArg: []byte("foo"), } req, _ := svc.InputService3TestCaseOperation1Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"BlobArg": "Zm9v"}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers if e, a := "application/x-amz-json-1.1", r.Header.Get("Content-Type"); e != a { t.Errorf("expect Content-Type %v header value, got %v", e, a) } if e, a := "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target"); e != a { t.Errorf("expect X-Amz-Target %v header value, got %v", e, a) } } func TestInputService3ProtocolTestBase64EncodedBlobsCase2(t testing.T) { svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService3TestShapeInputService3TestCaseOperation2Input{ BlobMap: map[string][]byte{ "key1": []byte("foo"), "key2": []byte("bar"), }, } req, _ := svc.InputService3TestCaseOperation2Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"BlobMap": {"key1": "Zm9v", "key2": "YmFy"}}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers if e, a := "application/x-amz-json-1.1", r.Header.Get("Content-Type"); e != a { t.Errorf("expect Content-Type %v header value, got %v", e, a) } if e, a := "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target"); e != a { t.Errorf("expect X-Amz-Target %v header value, got %v", e, a) } } func TestInputService4ProtocolTestNestedBlobsCase1(t testing.T) { svc := NewInputService4ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService4TestShapeInputService4TestCaseOperation1Input{ ListParam: [][]byte{ []byte("foo"), []byte("bar"), }, } req, _ := svc.InputService4TestCaseOperation1Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"ListParam": ["Zm9v", "YmFy"]}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers if e, a := "application/x-amz-json-1.1", r.Header.Get("Content-Type"); e != a { t.Errorf("expect Content-Type %v header value, got %v", e, a) } if e, a := "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target"); e != a { t.Errorf("expect X-Amz-Target %v header value, got %v", e, a) } } func TestInputService5ProtocolTestRecursiveShapesCase1(t testing.T) { svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService5TestShapeInputService5TestCaseOperation1Input{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ NoRecurse: aws.String("foo"), }, } req, _ := svc.InputService5TestCaseOperation1Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"RecursiveStruct": {"NoRecurse": "foo"}}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers if e, a := "application/x-amz-json-1.1", r.Header.Get("Content-Type"); e != a { t.Errorf("expect Content-Type %v header value, got %v", e, a) } if e, a := "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target"); e != a { t.Errorf("expect X-Amz-Target %v header value, got %v", e, a) } } func TestInputService5ProtocolTestRecursiveShapesCase2(t testing.T) { svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService5TestShapeInputService5TestCaseOperation2Input{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ NoRecurse: aws.String("foo"), }, }, } req, _ := svc.InputService5TestCaseOperation2Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"RecursiveStruct": {"RecursiveStruct": {"NoRecurse": "foo"}}}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers if e, a := "application/x-amz-json-1.1", r.Header.Get("Content-Type"); e != a { t.Errorf("expect Content-Type %v header value, got %v", e, a) } if e, a := "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target"); e != a { t.Errorf("expect X-Amz-Target %v header value, got %v", e, a) } } func TestInputService5ProtocolTestRecursiveShapesCase3(t testing.T) { svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService5TestShapeInputService5TestCaseOperation3Input{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ NoRecurse: aws.String("foo"), }, }, }, }, } req, _ := svc.InputService5TestCaseOperation3Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"RecursiveStruct": {"RecursiveStruct": {"RecursiveStruct": {"RecursiveStruct": {"NoRecurse": "foo"}}}}}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers if e, a := "application/x-amz-json-1.1", r.Header.Get("Content-Type"); e != a { t.Errorf("expect Content-Type %v header value, got %v", e, a) } if e, a := "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target"); e != a { t.Errorf("expect X-Amz-Target %v header value, got %v", e, a) } } func TestInputService5ProtocolTestRecursiveShapesCase4(t testing.T) { svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService5TestShapeInputService5TestCaseOperation4Input{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ RecursiveList: []InputService5TestShapeRecursiveStructType{ { NoRecurse: aws.String("foo"), }, { NoRecurse: aws.String("bar"), }, }, }, } req, _ := svc.InputService5TestCaseOperation4Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"RecursiveStruct": {"RecursiveList": [{"NoRecurse": "foo"}, {"NoRecurse": "bar"}]}}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers if e, a := "application/x-amz-json-1.1", r.Header.Get("Content-Type"); e != a { t.Errorf("expect Content-Type %v header value, got %v", e, a) } if e, a := "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target"); e != a { t.Errorf("expect X-Amz-Target %v header value, got %v", e, a) } } func TestInputService5ProtocolTestRecursiveShapesCase5(t testing.T) { svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService5TestShapeInputService5TestCaseOperation5Input{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ RecursiveList: []InputService5TestShapeRecursiveStructType{ { NoRecurse: aws.String("foo"), }, { RecursiveStruct: &InputService5TestShapeRecursiveStructType{ NoRecurse: aws.String("bar"), }, }, }, }, } req, _ := svc.InputService5TestCaseOperation5Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"RecursiveStruct": {"RecursiveList": [{"NoRecurse": "foo"}, {"RecursiveStruct": {"NoRecurse": "bar"}}]}}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers if e, a := "application/x-amz-json-1.1", r.Header.Get("Content-Type"); e != a { t.Errorf("expect Content-Type %v header value, got %v", e, a) } if e, a := "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target"); e != a { t.Errorf("expect X-Amz-Target %v header value, got %v", e, a) } } func TestInputService5ProtocolTestRecursiveShapesCase6(t testing.T) { svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService5TestShapeInputService5TestCaseOperation6Input{ RecursiveStruct: &InputService5TestShapeRecursiveStructType{ RecursiveMap: map[string]InputService5TestShapeRecursiveStructType{ "bar": { NoRecurse: aws.String("bar"), }, "foo": { NoRecurse: aws.String("foo"), }, }, }, } req, _ := svc.InputService5TestCaseOperation6Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"RecursiveStruct": {"RecursiveMap": {"foo": {"NoRecurse": "foo"}, "bar": {"NoRecurse": "bar"}}}}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers if e, a := "application/x-amz-json-1.1", r.Header.Get("Content-Type"); e != a { t.Errorf("expect Content-Type %v header value, got %v", e, a) } if e, a := "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target"); e != a { t.Errorf("expect X-Amz-Target %v header value, got %v", e, a) } } func TestInputService6ProtocolTestEmptyMapsCase1(t testing.T) { svc := NewInputService6ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService6TestShapeInputService6TestCaseOperation1Input{ Map: map[string]string{}, } req, _ := svc.InputService6TestCaseOperation1Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"Map": {}}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) // assert headers if e, a := "application/x-amz-json-1.1", r.Header.Get("Content-Type"); e != a { t.Errorf("expect Content-Type %v header value, got %v", e, a) } if e, a := "com.amazonaws.foo.OperationName", r.Header.Get("X-Amz-Target"); e != a { t.Errorf("expect X-Amz-Target %v header value, got %v", e, a) } } func TestInputService7ProtocolTestIdempotencyTokenAutoFillCase1(t testing.T) { svc := NewInputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService7TestShapeInputService7TestCaseOperation1Input{ Token: aws.String("abc123"), } req, _ := svc.InputService7TestCaseOperation1Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"Token": "abc123"}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) } func TestInputService7ProtocolTestIdempotencyTokenAutoFillCase2(t testing.T) { svc := NewInputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService7TestShapeInputService7TestCaseOperation2Input{} req, _ := svc.InputService7TestCaseOperation2Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"Token": "00000000-0000-4000-8000-000000000000"}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) } func TestInputService8ProtocolTestEnumCase1(t testing.T) { svc := NewInputService8ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService8TestShapeInputService8TestCaseOperation1Input{ FooEnum: aws.String("foo"), ListEnums: []string{ aws.String("foo"), aws.String(""), aws.String("bar"), }, } req, _ := svc.InputService8TestCaseOperation1Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"FooEnum": "foo", "ListEnums": ["foo", "", "bar"]}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) } func TestInputService8ProtocolTestEnumCase2(t testing.T) { svc := NewInputService8ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService8TestShapeInputService8TestCaseOperation2Input{} req, _ := svc.InputService8TestCaseOperation2Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert URL awstesting.AssertURL(t, "https://test/", r.URL.String()) } func TestInputService9ProtocolTestEndpointHostTraitStaticPrefixCase1(t testing.T) { svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://service.region.amazonaws.com")}) input := &InputService9TestShapeInputService9TestCaseOperation1Input{ Name: aws.String("myname"), } req, _ := svc.InputService9TestCaseOperation1Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"Name": "myname"}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://data-service.region.amazonaws.com/", r.URL.String()) // assert headers if e, a := "application/x-amz-json-1.1", r.Header.Get("Content-Type"); e != a { t.Errorf("expect Content-Type %v header value, got %v", e, a) } if e, a := "com.amazonaws.foo.StaticOp", r.Header.Get("X-Amz-Target"); e != a { t.Errorf("expect X-Amz-Target %v header value, got %v", e, a) } } func TestInputService9ProtocolTestEndpointHostTraitStaticPrefixCase2(t *testing.T) { svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://service.region.amazonaws.com")}) input := &InputService9TestShapeInputService9TestCaseOperation2Input{ Name: aws.String("myname"), } req, _ := svc.InputService9TestCaseOperation2Request(input) r := req.HTTPRequest // build request req.Build() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } req.Sign() if req.Error != nil { t.Errorf("expect no error, got %v", req.Error) } // assert body if r.Body == nil { t.Errorf("expect body not to be nil") } body, _ := ioutil.ReadAll(r.Body) awstesting.AssertJSON(t, `{"Name": "myname"}`, util.Trim(string(body))) if e, a := int64(len(body)), r.ContentLength; e != a { t.Errorf("expect serialized body length to match %v ContentLength, got %v", e, a) } // assert URL awstesting.AssertURL(t, "https://foo-myname.service.region.amazonaws.com/", r.URL.String()) // assert headers if e, a := "application/x-amz-json-1.1", r.Header.Get("Content-Type"); e != a { t.Errorf("expect Content-Type %v header value, got %v", e, a) } if e, a := "com.amazonaws.foo.MemberRefOp", r.Header.Get("X-Amz-Target"); e != a { t.Errorf("expect X-Amz-Target %v header value, got %v", e, a) } }	119.83 KB	2025-05-25 12:27
📄 jsonrpc.go // Package jsonrpc provides JSON RPC utilities for serialization of AWS // requests and responses. package jsonrpc //go:generate go run -tags codegen ../../../private/model/cli/gen-protocol-tests ../../../models/protocol_tests/input/json.json build_test.go //go:generate go run -tags codegen ../../../private/model/cli/gen-protocol-tests ../../../models/protocol_tests/output/json.json unmarshal_test.go import ( "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/private/protocol/json/jsonutil" "github.com/aws/aws-sdk-go/private/protocol/rest" ) var emptyJSON = []byte("{}") // BuildHandler is a named request handler for building jsonrpc protocol // requests var BuildHandler = request.NamedHandler{ Name: "awssdk.jsonrpc.Build", Fn: Build, } // UnmarshalHandler is a named request handler for unmarshaling jsonrpc // protocol requests var UnmarshalHandler = request.NamedHandler{ Name: "awssdk.jsonrpc.Unmarshal", Fn: Unmarshal, } // UnmarshalMetaHandler is a named request handler for unmarshaling jsonrpc // protocol request metadata var UnmarshalMetaHandler = request.NamedHandler{ Name: "awssdk.jsonrpc.UnmarshalMeta", Fn: UnmarshalMeta, } // Build builds a JSON payload for a JSON RPC request. func Build(req request.Request) { var buf []byte var err error if req.ParamsFilled() { buf, err = jsonutil.BuildJSON(req.Params) if err != nil { req.Error = awserr.New(request.ErrCodeSerialization, "failed encoding JSON RPC request", err) return } } else { buf = emptyJSON } // Always serialize the body, don't suppress it. req.SetBufferBody(buf) if req.ClientInfo.TargetPrefix != "" { target := req.ClientInfo.TargetPrefix + "." + req.Operation.Name req.HTTPRequest.Header.Add("X-Amz-Target", target) } // Only set the content type if one is not already specified and an // JSONVersion is specified. if ct, v := req.HTTPRequest.Header.Get("Content-Type"), req.ClientInfo.JSONVersion; len(ct) == 0 && len(v) != 0 { jsonVersion := req.ClientInfo.JSONVersion req.HTTPRequest.Header.Set("Content-Type", "application/x-amz-json-"+jsonVersion) } } // Unmarshal unmarshals a response for a JSON RPC service. func Unmarshal(req request.Request) { defer req.HTTPResponse.Body.Close() if req.DataFilled() { err := jsonutil.UnmarshalJSON(req.Data, req.HTTPResponse.Body) if err != nil { req.Error = awserr.NewRequestFailure( awserr.New(request.ErrCodeSerialization, "failed decoding JSON RPC response", err), req.HTTPResponse.StatusCode, req.RequestID, ) } } return } // UnmarshalMeta unmarshals headers from a response for a JSON RPC service. func UnmarshalMeta(req *request.Request) { rest.UnmarshalMeta(req) }	2.69 KB	2025-05-25 12:27
📄 unmarshal_error.go package jsonrpc import ( "bytes" "io" "io/ioutil" "net/http" "strings" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/private/protocol" "github.com/aws/aws-sdk-go/private/protocol/json/jsonutil" ) const ( awsQueryError = "x-amzn-query-error" // A valid header example - "x-amzn-query-error": "<QueryErrorCode>;<ErrorType>" awsQueryErrorPartsCount = 2 ) // UnmarshalTypedError provides unmarshaling errors API response errors // for both typed and untyped errors. type UnmarshalTypedError struct { exceptions map[string]func(protocol.ResponseMetadata) error queryExceptions map[string]func(protocol.ResponseMetadata, string) error } // NewUnmarshalTypedError returns an UnmarshalTypedError initialized for the // set of exception names to the error unmarshalers func NewUnmarshalTypedError(exceptions map[string]func(protocol.ResponseMetadata) error) UnmarshalTypedError { return &UnmarshalTypedError{ exceptions: exceptions, queryExceptions: map[string]func(protocol.ResponseMetadata, string) error{}, } } // NewUnmarshalTypedErrorWithOptions works similar to NewUnmarshalTypedError applying options to the UnmarshalTypedError // before returning it func NewUnmarshalTypedErrorWithOptions(exceptions map[string]func(protocol.ResponseMetadata) error, optFns ...func(UnmarshalTypedError)) UnmarshalTypedError { unmarshaledError := NewUnmarshalTypedError(exceptions) for _, fn := range optFns { fn(unmarshaledError) } return unmarshaledError } // WithQueryCompatibility is a helper function to construct a functional option for use with NewUnmarshalTypedErrorWithOptions. // The queryExceptions given act as an override for unmarshalling errors when query compatible error codes are found. // See also [awsQueryCompatible trait] // // [awsQueryCompatible trait]: https://smithy.io/2.0/aws/protocols/aws-query-protocol.html#aws-protocols-awsquerycompatible-trait func WithQueryCompatibility(queryExceptions map[string]func(protocol.ResponseMetadata, string) error) func(UnmarshalTypedError) { return func(typedError UnmarshalTypedError) { typedError.queryExceptions = queryExceptions } } // UnmarshalError attempts to unmarshal the HTTP response error as a known // error type. If unable to unmarshal the error type, the generic SDK error // type will be used. func (u UnmarshalTypedError) UnmarshalError( resp http.Response, respMeta protocol.ResponseMetadata, ) (error, error) { var buf bytes.Buffer var jsonErr jsonErrorResponse teeReader := io.TeeReader(resp.Body, &buf) err := jsonutil.UnmarshalJSONError(&jsonErr, teeReader) if err != nil { return nil, err } body := ioutil.NopCloser(&buf) // Code may be separated by hash(#), with the last element being the code // used by the SDK. codeParts := strings.SplitN(jsonErr.Code, "#", 2) code := codeParts[len(codeParts)-1] msg := jsonErr.Message queryCodeParts := queryCodeParts(resp, u) if fn, ok := u.exceptions[code]; ok { // If query-compatible exceptions are found and query-error-header is found, // then use associated constructor to get exception with query error code. // // If exception code is known, use associated constructor to get a value // for the exception that the JSON body can be unmarshaled into. var v error queryErrFn, queryExceptionsFound := u.queryExceptions[code] if len(queryCodeParts) == awsQueryErrorPartsCount && queryExceptionsFound { v = queryErrFn(respMeta, queryCodeParts[0]) } else { v = fn(respMeta) } err := jsonutil.UnmarshalJSONCaseInsensitive(v, body) if err != nil { return nil, err } return v, nil } if len(queryCodeParts) == awsQueryErrorPartsCount && len(u.queryExceptions) > 0 { code = queryCodeParts[0] } // fallback to unmodeled generic exceptions return awserr.NewRequestFailure( awserr.New(code, msg, nil), respMeta.StatusCode, respMeta.RequestID, ), nil } // A valid header example - "x-amzn-query-error": "<QueryErrorCode>;<ErrorType>" func queryCodeParts(resp http.Response, u UnmarshalTypedError) []string { queryCodeHeader := resp.Header.Get(awsQueryError) var queryCodeParts []string if queryCodeHeader != "" && len(u.queryExceptions) > 0 { queryCodeParts = strings.Split(queryCodeHeader, ";") } return queryCodeParts } // UnmarshalErrorHandler is a named request handler for unmarshaling jsonrpc // protocol request errors var UnmarshalErrorHandler = request.NamedHandler{ Name: "awssdk.jsonrpc.UnmarshalError", Fn: UnmarshalError, } // UnmarshalError unmarshals an error response for a JSON RPC service. func UnmarshalError(req request.Request) { defer req.HTTPResponse.Body.Close() var jsonErr jsonErrorResponse err := jsonutil.UnmarshalJSONError(&jsonErr, req.HTTPResponse.Body) if err != nil { req.Error = awserr.NewRequestFailure( awserr.New(request.ErrCodeSerialization, "failed to unmarshal error message", err), req.HTTPResponse.StatusCode, req.RequestID, ) return } codes := strings.SplitN(jsonErr.Code, "#", 2) req.Error = awserr.NewRequestFailure( awserr.New(codes[len(codes)-1], jsonErr.Message, nil), req.HTTPResponse.StatusCode, req.RequestID, ) } type jsonErrorResponse struct { Code string `json:"__type"` Message string `json:"message"` }	5.18 KB	2025-05-25 12:27
📄 unmarshal_error_test.go //go:build go1.7 // +build go1.7 package jsonrpc import ( "bytes" "encoding/hex" "io/ioutil" "net/http" "reflect" "strings" "testing" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/private/protocol" ) const unknownErrJSON = `{"__type":"UnknownError", "message":"error message", "something":123}` const simpleErrJSON = `{"__type":"SimpleError", "message":"some message", "foo":123}` const simpleCasedErrJSON = `{"__type":"SimpleError", "Message":"some message", "foo":123}` type SimpleError struct { _ struct{} `type:"structure"` error Message2 string `type:"string" locationName:"message"` Foo int64 `type:"integer" locationName:"foo"` } const otherErrJSON = `{"__type":"OtherError", "message":"some message"}` const complexCodeErrJSON = `{"__type":"foo.bar#OtherError", "message":"some message"}` type OtherError struct { _ struct{} `type:"structure"` error Message2 string `type:"string" locationName:"message"` } const complexErrJSON = `{"__type":"ComplexError", "message":"some message", "foo": {"bar":"abc123", "baz":123}}` type ComplexError struct { _ struct{} `type:"structure"` error Message2 string `type:"string" locationName:"message"` Foo ErrorNested `type:"structure" locationName:"foo"` } type ErrorNested struct { _ struct{} `type:"structure"` Bar string `type:"string" locationName:"bar"` Baz int64 `type:"integer" locationName:"baz"` } func TestUnmarshalTypedError(t testing.T) { respMeta := protocol.ResponseMetadata{ StatusCode: 400, RequestID: "abc123", } exceptions := map[string]func(protocol.ResponseMetadata) error{ "SimpleError": func(meta protocol.ResponseMetadata) error { return &SimpleError{} }, "OtherError": func(meta protocol.ResponseMetadata) error { return &OtherError{} }, "ComplexError": func(meta protocol.ResponseMetadata) error { return &ComplexError{} }, } cases := map[string]struct { Response http.Response Expect error Err string }{ "simple error": { Response: &http.Response{ Header: http.Header{}, Body: ioutil.NopCloser(strings.NewReader(simpleErrJSON)), }, Expect: &SimpleError{ Message2: aws.String("some message"), Foo: aws.Int64(123), }, }, "other error": { Response: &http.Response{ Header: http.Header{}, Body: ioutil.NopCloser(strings.NewReader(otherErrJSON)), }, Expect: &OtherError{ Message2: aws.String("some message"), }, }, "other complex Code error": { Response: &http.Response{ Header: http.Header{}, Body: ioutil.NopCloser(strings.NewReader(complexCodeErrJSON)), }, Expect: &OtherError{ Message2: aws.String("some message"), }, }, "complex error": { Response: &http.Response{ Header: http.Header{}, Body: ioutil.NopCloser(strings.NewReader(complexErrJSON)), }, Expect: &ComplexError{ Message2: aws.String("some message"), Foo: &ErrorNested{ Bar: aws.String("abc123"), Baz: aws.Int64(123), }, }, }, "unknown error": { Response: &http.Response{ Header: http.Header{}, Body: ioutil.NopCloser(strings.NewReader(unknownErrJSON)), }, Expect: awserr.NewRequestFailure( awserr.New("UnknownError", "error message", nil), respMeta.StatusCode, respMeta.RequestID, ), }, "invalid error": { Response: &http.Response{ StatusCode: 400, Header: http.Header{}, Body: ioutil.NopCloser(strings.NewReader(`{`)), }, Err: "failed decoding", }, "mixed case fields": { Response: &http.Response{ Header: http.Header{}, Body: ioutil.NopCloser(strings.NewReader(simpleCasedErrJSON)), }, Expect: &SimpleError{ Message2: aws.String("some message"), Foo: aws.Int64(123), }, }, } for name, c := range cases { t.Run(name, func(t testing.T) { u := NewUnmarshalTypedError(exceptions) v, err := u.UnmarshalError(c.Response, respMeta) if len(c.Err) != 0 { if err == nil { t.Fatalf("expect error, got none") } if e, a := c.Err, err.Error(); !strings.Contains(a, e) { t.Fatalf("expect %v in error, got %v", e, a) } } else if err != nil { t.Fatalf("expect no error, got %v", err) } if e, a := c.Expect, v; !reflect.DeepEqual(e, a) { t.Errorf("expect %+#v, got %#+v", e, a) } }) } } func TestUnmarshalError_SerializationError(t testing.T) { cases := map[string]struct { Request request.Request ExpectMsg string ExpectBytes []byte }{ "empty body": { Request: &request.Request{ Data: &struct{}{}, HTTPResponse: &http.Response{ StatusCode: 400, Header: http.Header{ "X-Amzn-Requestid": []string{"abc123"}, }, Body: ioutil.NopCloser( bytes.NewReader([]byte{}), ), }, }, ExpectMsg: "error message missing", }, "HTML body": { Request: &request.Request{ Data: &struct{}{}, HTTPResponse: &http.Response{ StatusCode: 400, Header: http.Header{ "X-Amzn-Requestid": []string{"abc123"}, }, Body: ioutil.NopCloser( bytes.NewReader([]byte(`<html></html>`)), ), }, }, ExpectBytes: []byte(`<html></html>`), ExpectMsg: "failed decoding", }, } for name, c := range cases { t.Run(name, func(t *testing.T) { req := c.Request UnmarshalError(req) if req.Error == nil { t.Fatal("expect error, got none") } aerr := req.Error.(awserr.RequestFailure) if e, a := request.ErrCodeSerialization, aerr.Code(); e != a { t.Errorf("expect %v, got %v", e, a) } uerr := aerr.OrigErr().(awserr.UnmarshalError) if e, a := c.ExpectMsg, uerr.Message(); !strings.Contains(a, e) { t.Errorf("Expect %q, in %q", e, a) } if e, a := c.ExpectBytes, uerr.Bytes(); !bytes.Equal(e, a) { t.Errorf("expect:\n%v\nactual:\n%v", hex.Dump(e), hex.Dump(a)) } }) } }	5.83 KB	2025-05-25 12:27
📄 unmarshal_test.go // Code generated by models/protocol_tests/generate.go. DO NOT EDIT. package jsonrpc_test import ( "bytes" "encoding/json" "encoding/xml" "fmt" "io" "io/ioutil" "net/http" "net/url" "reflect" "testing" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/client" "github.com/aws/aws-sdk-go/aws/client/metadata" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/aws/signer/v4" "github.com/aws/aws-sdk-go/awstesting" "github.com/aws/aws-sdk-go/awstesting/unit" "github.com/aws/aws-sdk-go/private/protocol" "github.com/aws/aws-sdk-go/private/protocol/jsonrpc" "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil" "github.com/aws/aws-sdk-go/private/util" ) 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 var _ = aws.String var _ = fmt.Println var _ = reflect.Value{} func init() { protocol.RandReader = &awstesting.ZeroReader{} } // OutputService1ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService1ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService1ProtocolTest struct { client.Client } // New creates a new instance of the OutputService1ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a OutputService1ProtocolTest client from just a session. // svc := outputservice1protocoltest.New(mySession) // // // Create a OutputService1ProtocolTest client with additional configuration // svc := outputservice1protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService1ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService1ProtocolTest { c := p.ClientConfig("outputservice1protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService1ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newOutputService1ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService1ProtocolTest { svc := &OutputService1ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService1ProtocolTest", ServiceID: "OutputService1ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService1ProtocolTest operation and runs any // custom request initialization. func (c OutputService1ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService1TestCaseOperation1 = "OperationName" // OutputService1TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService1TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See OutputService1TestCaseOperation1 for more information on using the OutputService1TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the OutputService1TestCaseOperation1Request method. // req, resp := client.OutputService1TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService1ProtocolTest) OutputService1TestCaseOperation1Request(input OutputService1TestShapeOutputService1TestCaseOperation1Input) (req request.Request, output OutputService1TestShapeOutputService1TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService1TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &OutputService1TestShapeOutputService1TestCaseOperation1Input{} } output = &OutputService1TestShapeOutputService1TestCaseOperation1Output{} req = c.newRequest(op, input, output) return } // OutputService1TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation OutputService1TestCaseOperation1 for usage and error information. func (c OutputService1ProtocolTest) OutputService1TestCaseOperation1(input OutputService1TestShapeOutputService1TestCaseOperation1Input) (OutputService1TestShapeOutputService1TestCaseOperation1Output, error) { req, out := c.OutputService1TestCaseOperation1Request(input) return out, req.Send() } // OutputService1TestCaseOperation1WithContext is the same as OutputService1TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService1TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c OutputService1ProtocolTest) OutputService1TestCaseOperation1WithContext(ctx aws.Context, input OutputService1TestShapeOutputService1TestCaseOperation1Input, opts ...request.Option) (OutputService1TestShapeOutputService1TestCaseOperation1Output, error) { req, out := c.OutputService1TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService1TestShapeOutputService1TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService1TestShapeOutputService1TestCaseOperation1Output struct { _ struct{} `type:"structure"` Char string `type:"character"` Double float64 `type:"double"` FalseBool bool `type:"boolean"` Float float64 `type:"float"` Long int64 `type:"long"` Num int64 `type:"integer"` Str string `type:"string"` TrueBool bool `type:"boolean"` } // SetChar sets the Char field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation1Output) SetChar(v string) OutputService1TestShapeOutputService1TestCaseOperation1Output { s.Char = &v return s } // SetDouble sets the Double field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation1Output) SetDouble(v float64) OutputService1TestShapeOutputService1TestCaseOperation1Output { s.Double = &v return s } // SetFalseBool sets the FalseBool field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation1Output) SetFalseBool(v bool) OutputService1TestShapeOutputService1TestCaseOperation1Output { s.FalseBool = &v return s } // SetFloat sets the Float field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation1Output) SetFloat(v float64) OutputService1TestShapeOutputService1TestCaseOperation1Output { s.Float = &v return s } // SetLong sets the Long field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation1Output) SetLong(v int64) OutputService1TestShapeOutputService1TestCaseOperation1Output { s.Long = &v return s } // SetNum sets the Num field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation1Output) SetNum(v int64) OutputService1TestShapeOutputService1TestCaseOperation1Output { s.Num = &v return s } // SetStr sets the Str field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation1Output) SetStr(v string) OutputService1TestShapeOutputService1TestCaseOperation1Output { s.Str = &v return s } // SetTrueBool sets the TrueBool field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation1Output) SetTrueBool(v bool) OutputService1TestShapeOutputService1TestCaseOperation1Output { s.TrueBool = &v return s } // OutputService2ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService2ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService2ProtocolTest struct { client.Client } // New creates a new instance of the OutputService2ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a OutputService2ProtocolTest client from just a session. // svc := outputservice2protocoltest.New(mySession) // // // Create a OutputService2ProtocolTest client with additional configuration // svc := outputservice2protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService2ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService2ProtocolTest { c := p.ClientConfig("outputservice2protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService2ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newOutputService2ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService2ProtocolTest { svc := &OutputService2ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService2ProtocolTest", ServiceID: "OutputService2ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService2ProtocolTest operation and runs any // custom request initialization. func (c OutputService2ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService2TestCaseOperation1 = "OperationName" // OutputService2TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService2TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See OutputService2TestCaseOperation1 for more information on using the OutputService2TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the OutputService2TestCaseOperation1Request method. // req, resp := client.OutputService2TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService2ProtocolTest) OutputService2TestCaseOperation1Request(input OutputService2TestShapeOutputService2TestCaseOperation1Input) (req request.Request, output OutputService2TestShapeOutputService2TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService2TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &OutputService2TestShapeOutputService2TestCaseOperation1Input{} } output = &OutputService2TestShapeOutputService2TestCaseOperation1Output{} req = c.newRequest(op, input, output) return } // OutputService2TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation OutputService2TestCaseOperation1 for usage and error information. func (c OutputService2ProtocolTest) OutputService2TestCaseOperation1(input OutputService2TestShapeOutputService2TestCaseOperation1Input) (OutputService2TestShapeOutputService2TestCaseOperation1Output, error) { req, out := c.OutputService2TestCaseOperation1Request(input) return out, req.Send() } // OutputService2TestCaseOperation1WithContext is the same as OutputService2TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService2TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c OutputService2ProtocolTest) OutputService2TestCaseOperation1WithContext(ctx aws.Context, input OutputService2TestShapeOutputService2TestCaseOperation1Input, opts ...request.Option) (OutputService2TestShapeOutputService2TestCaseOperation1Output, error) { req, out := c.OutputService2TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService2TestShapeBlobContainer struct { _ struct{} `type:"structure"` // Foo is automatically base64 encoded/decoded by the SDK. Foo []byte `locationName:"foo" type:"blob"` } // SetFoo sets the Foo field's value. func (s OutputService2TestShapeBlobContainer) SetFoo(v []byte) OutputService2TestShapeBlobContainer { s.Foo = v return s } type OutputService2TestShapeOutputService2TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService2TestShapeOutputService2TestCaseOperation1Output struct { _ struct{} `type:"structure"` // BlobMember is automatically base64 encoded/decoded by the SDK. BlobMember []byte `type:"blob"` StructMember OutputService2TestShapeBlobContainer `type:"structure"` } // SetBlobMember sets the BlobMember field's value. func (s OutputService2TestShapeOutputService2TestCaseOperation1Output) SetBlobMember(v []byte) OutputService2TestShapeOutputService2TestCaseOperation1Output { s.BlobMember = v return s } // SetStructMember sets the StructMember field's value. func (s OutputService2TestShapeOutputService2TestCaseOperation1Output) SetStructMember(v OutputService2TestShapeBlobContainer) OutputService2TestShapeOutputService2TestCaseOperation1Output { s.StructMember = v return s } // OutputService3ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService3ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService3ProtocolTest struct { client.Client } // New creates a new instance of the OutputService3ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a OutputService3ProtocolTest client from just a session. // svc := outputservice3protocoltest.New(mySession) // // // Create a OutputService3ProtocolTest client with additional configuration // svc := outputservice3protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService3ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService3ProtocolTest { c := p.ClientConfig("outputservice3protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService3ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newOutputService3ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService3ProtocolTest { svc := &OutputService3ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService3ProtocolTest", ServiceID: "OutputService3ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService3ProtocolTest operation and runs any // custom request initialization. func (c OutputService3ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService3TestCaseOperation1 = "OperationName" // OutputService3TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService3TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See OutputService3TestCaseOperation1 for more information on using the OutputService3TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the OutputService3TestCaseOperation1Request method. // req, resp := client.OutputService3TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService3ProtocolTest) OutputService3TestCaseOperation1Request(input OutputService3TestShapeOutputService3TestCaseOperation1Input) (req request.Request, output OutputService3TestShapeOutputService3TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService3TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &OutputService3TestShapeOutputService3TestCaseOperation1Input{} } output = &OutputService3TestShapeOutputService3TestCaseOperation1Output{} req = c.newRequest(op, input, output) return } // OutputService3TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation OutputService3TestCaseOperation1 for usage and error information. func (c OutputService3ProtocolTest) OutputService3TestCaseOperation1(input OutputService3TestShapeOutputService3TestCaseOperation1Input) (OutputService3TestShapeOutputService3TestCaseOperation1Output, error) { req, out := c.OutputService3TestCaseOperation1Request(input) return out, req.Send() } // OutputService3TestCaseOperation1WithContext is the same as OutputService3TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService3TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c OutputService3ProtocolTest) OutputService3TestCaseOperation1WithContext(ctx aws.Context, input OutputService3TestShapeOutputService3TestCaseOperation1Input, opts ...request.Option) (OutputService3TestShapeOutputService3TestCaseOperation1Output, error) { req, out := c.OutputService3TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService3TestShapeOutputService3TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService3TestShapeOutputService3TestCaseOperation1Output struct { _ struct{} `type:"structure"` StructMember OutputService3TestShapeTimeContainer `type:"structure"` TimeArg time.Time `type:"timestamp"` TimeCustom time.Time `type:"timestamp" timestampFormat:"rfc822"` TimeFormat time.Time `type:"timestamp" timestampFormat:"iso8601"` } // SetStructMember sets the StructMember field's value. func (s OutputService3TestShapeOutputService3TestCaseOperation1Output) SetStructMember(v OutputService3TestShapeTimeContainer) OutputService3TestShapeOutputService3TestCaseOperation1Output { s.StructMember = v return s } // SetTimeArg sets the TimeArg field's value. func (s OutputService3TestShapeOutputService3TestCaseOperation1Output) SetTimeArg(v time.Time) OutputService3TestShapeOutputService3TestCaseOperation1Output { s.TimeArg = &v return s } // SetTimeCustom sets the TimeCustom field's value. func (s OutputService3TestShapeOutputService3TestCaseOperation1Output) SetTimeCustom(v time.Time) OutputService3TestShapeOutputService3TestCaseOperation1Output { s.TimeCustom = &v return s } // SetTimeFormat sets the TimeFormat field's value. func (s OutputService3TestShapeOutputService3TestCaseOperation1Output) SetTimeFormat(v time.Time) OutputService3TestShapeOutputService3TestCaseOperation1Output { s.TimeFormat = &v return s } type OutputService3TestShapeTimeContainer struct { _ struct{} `type:"structure"` Bar time.Time `locationName:"bar" type:"timestamp" timestampFormat:"iso8601"` Foo time.Time `locationName:"foo" type:"timestamp"` } // SetBar sets the Bar field's value. func (s OutputService3TestShapeTimeContainer) SetBar(v time.Time) OutputService3TestShapeTimeContainer { s.Bar = &v return s } // SetFoo sets the Foo field's value. func (s OutputService3TestShapeTimeContainer) SetFoo(v time.Time) OutputService3TestShapeTimeContainer { s.Foo = &v return s } // OutputService4ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService4ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService4ProtocolTest struct { client.Client } // New creates a new instance of the OutputService4ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a OutputService4ProtocolTest client from just a session. // svc := outputservice4protocoltest.New(mySession) // // // Create a OutputService4ProtocolTest client with additional configuration // svc := outputservice4protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService4ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService4ProtocolTest { c := p.ClientConfig("outputservice4protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService4ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newOutputService4ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService4ProtocolTest { svc := &OutputService4ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService4ProtocolTest", ServiceID: "OutputService4ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService4ProtocolTest operation and runs any // custom request initialization. func (c OutputService4ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService4TestCaseOperation1 = "OperationName" // OutputService4TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService4TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See OutputService4TestCaseOperation1 for more information on using the OutputService4TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the OutputService4TestCaseOperation1Request method. // req, resp := client.OutputService4TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(input OutputService4TestShapeOutputService4TestCaseOperation1Input) (req request.Request, output OutputService4TestShapeOutputService4TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService4TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &OutputService4TestShapeOutputService4TestCaseOperation1Input{} } output = &OutputService4TestShapeOutputService4TestCaseOperation1Output{} req = c.newRequest(op, input, output) return } // OutputService4TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation OutputService4TestCaseOperation1 for usage and error information. func (c OutputService4ProtocolTest) OutputService4TestCaseOperation1(input OutputService4TestShapeOutputService4TestCaseOperation1Input) (OutputService4TestShapeOutputService4TestCaseOperation1Output, error) { req, out := c.OutputService4TestCaseOperation1Request(input) return out, req.Send() } // OutputService4TestCaseOperation1WithContext is the same as OutputService4TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService4TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c OutputService4ProtocolTest) OutputService4TestCaseOperation1WithContext(ctx aws.Context, input OutputService4TestShapeOutputService4TestCaseOperation1Input, opts ...request.Option) (OutputService4TestShapeOutputService4TestCaseOperation1Output, error) { req, out := c.OutputService4TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opOutputService4TestCaseOperation2 = "OperationName" // OutputService4TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the OutputService4TestCaseOperation2 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See OutputService4TestCaseOperation2 for more information on using the OutputService4TestCaseOperation2 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the OutputService4TestCaseOperation2Request method. // req, resp := client.OutputService4TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService4ProtocolTest) OutputService4TestCaseOperation2Request(input OutputService4TestShapeOutputService4TestCaseOperation2Input) (req request.Request, output OutputService4TestShapeOutputService4TestCaseOperation2Output) { op := &request.Operation{ Name: opOutputService4TestCaseOperation2, HTTPPath: "/", } if input == nil { input = &OutputService4TestShapeOutputService4TestCaseOperation2Input{} } output = &OutputService4TestShapeOutputService4TestCaseOperation2Output{} req = c.newRequest(op, input, output) return } // OutputService4TestCaseOperation2 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation OutputService4TestCaseOperation2 for usage and error information. func (c OutputService4ProtocolTest) OutputService4TestCaseOperation2(input OutputService4TestShapeOutputService4TestCaseOperation2Input) (OutputService4TestShapeOutputService4TestCaseOperation2Output, error) { req, out := c.OutputService4TestCaseOperation2Request(input) return out, req.Send() } // OutputService4TestCaseOperation2WithContext is the same as OutputService4TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See OutputService4TestCaseOperation2 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c OutputService4ProtocolTest) OutputService4TestCaseOperation2WithContext(ctx aws.Context, input OutputService4TestShapeOutputService4TestCaseOperation2Input, opts ...request.Option) (OutputService4TestShapeOutputService4TestCaseOperation2Output, error) { req, out := c.OutputService4TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService4TestShapeOutputService4TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService4TestShapeOutputService4TestCaseOperation1Output struct { _ struct{} `type:"structure"` ListMember []string `type:"list"` ListMemberMap []map[string]string `type:"list"` ListMemberStruct []OutputService4TestShapeStructType `type:"list"` } // SetListMember sets the ListMember field's value. func (s OutputService4TestShapeOutputService4TestCaseOperation1Output) SetListMember(v []string) OutputService4TestShapeOutputService4TestCaseOperation1Output { s.ListMember = v return s } // SetListMemberMap sets the ListMemberMap field's value. func (s OutputService4TestShapeOutputService4TestCaseOperation1Output) SetListMemberMap(v []map[string]string) OutputService4TestShapeOutputService4TestCaseOperation1Output { s.ListMemberMap = v return s } // SetListMemberStruct sets the ListMemberStruct field's value. func (s OutputService4TestShapeOutputService4TestCaseOperation1Output) SetListMemberStruct(v []OutputService4TestShapeStructType) OutputService4TestShapeOutputService4TestCaseOperation1Output { s.ListMemberStruct = v return s } type OutputService4TestShapeOutputService4TestCaseOperation2Input struct { _ struct{} `type:"structure"` } type OutputService4TestShapeOutputService4TestCaseOperation2Output struct { _ struct{} `type:"structure"` ListMember []string `type:"list"` ListMemberMap []map[string]string `type:"list"` ListMemberStruct []OutputService4TestShapeStructType `type:"list"` } // SetListMember sets the ListMember field's value. func (s OutputService4TestShapeOutputService4TestCaseOperation2Output) SetListMember(v []string) OutputService4TestShapeOutputService4TestCaseOperation2Output { s.ListMember = v return s } // SetListMemberMap sets the ListMemberMap field's value. func (s OutputService4TestShapeOutputService4TestCaseOperation2Output) SetListMemberMap(v []map[string]string) OutputService4TestShapeOutputService4TestCaseOperation2Output { s.ListMemberMap = v return s } // SetListMemberStruct sets the ListMemberStruct field's value. func (s OutputService4TestShapeOutputService4TestCaseOperation2Output) SetListMemberStruct(v []OutputService4TestShapeStructType) OutputService4TestShapeOutputService4TestCaseOperation2Output { s.ListMemberStruct = v return s } type OutputService4TestShapeStructType struct { _ struct{} `type:"structure"` } // OutputService5ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService5ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService5ProtocolTest struct { client.Client } // New creates a new instance of the OutputService5ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a OutputService5ProtocolTest client from just a session. // svc := outputservice5protocoltest.New(mySession) // // // Create a OutputService5ProtocolTest client with additional configuration // svc := outputservice5protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService5ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService5ProtocolTest { c := p.ClientConfig("outputservice5protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService5ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newOutputService5ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService5ProtocolTest { svc := &OutputService5ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService5ProtocolTest", ServiceID: "OutputService5ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService5ProtocolTest operation and runs any // custom request initialization. func (c OutputService5ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService5TestCaseOperation1 = "OperationName" // OutputService5TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService5TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See OutputService5TestCaseOperation1 for more information on using the OutputService5TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the OutputService5TestCaseOperation1Request method. // req, resp := client.OutputService5TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService5ProtocolTest) OutputService5TestCaseOperation1Request(input OutputService5TestShapeOutputService5TestCaseOperation1Input) (req request.Request, output OutputService5TestShapeOutputService5TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService5TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &OutputService5TestShapeOutputService5TestCaseOperation1Input{} } output = &OutputService5TestShapeOutputService5TestCaseOperation1Output{} req = c.newRequest(op, input, output) return } // OutputService5TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation OutputService5TestCaseOperation1 for usage and error information. func (c OutputService5ProtocolTest) OutputService5TestCaseOperation1(input OutputService5TestShapeOutputService5TestCaseOperation1Input) (OutputService5TestShapeOutputService5TestCaseOperation1Output, error) { req, out := c.OutputService5TestCaseOperation1Request(input) return out, req.Send() } // OutputService5TestCaseOperation1WithContext is the same as OutputService5TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService5TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c OutputService5ProtocolTest) OutputService5TestCaseOperation1WithContext(ctx aws.Context, input OutputService5TestShapeOutputService5TestCaseOperation1Input, opts ...request.Option) (OutputService5TestShapeOutputService5TestCaseOperation1Output, error) { req, out := c.OutputService5TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService5TestShapeOutputService5TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService5TestShapeOutputService5TestCaseOperation1Output struct { _ struct{} `type:"structure"` MapMember map[string][]int64 `type:"map"` } // SetMapMember sets the MapMember field's value. func (s OutputService5TestShapeOutputService5TestCaseOperation1Output) SetMapMember(v map[string][]int64) OutputService5TestShapeOutputService5TestCaseOperation1Output { s.MapMember = v return s } // OutputService6ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService6ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService6ProtocolTest struct { client.Client } // New creates a new instance of the OutputService6ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a OutputService6ProtocolTest client from just a session. // svc := outputservice6protocoltest.New(mySession) // // // Create a OutputService6ProtocolTest client with additional configuration // svc := outputservice6protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService6ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService6ProtocolTest { c := p.ClientConfig("outputservice6protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService6ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newOutputService6ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService6ProtocolTest { svc := &OutputService6ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService6ProtocolTest", ServiceID: "OutputService6ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService6ProtocolTest operation and runs any // custom request initialization. func (c OutputService6ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService6TestCaseOperation1 = "OperationName" // OutputService6TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService6TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See OutputService6TestCaseOperation1 for more information on using the OutputService6TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the OutputService6TestCaseOperation1Request method. // req, resp := client.OutputService6TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService6ProtocolTest) OutputService6TestCaseOperation1Request(input OutputService6TestShapeOutputService6TestCaseOperation1Input) (req request.Request, output OutputService6TestShapeOutputService6TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService6TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &OutputService6TestShapeOutputService6TestCaseOperation1Input{} } output = &OutputService6TestShapeOutputService6TestCaseOperation1Output{} req = c.newRequest(op, input, output) return } // OutputService6TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation OutputService6TestCaseOperation1 for usage and error information. func (c OutputService6ProtocolTest) OutputService6TestCaseOperation1(input OutputService6TestShapeOutputService6TestCaseOperation1Input) (OutputService6TestShapeOutputService6TestCaseOperation1Output, error) { req, out := c.OutputService6TestCaseOperation1Request(input) return out, req.Send() } // OutputService6TestCaseOperation1WithContext is the same as OutputService6TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService6TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c OutputService6ProtocolTest) OutputService6TestCaseOperation1WithContext(ctx aws.Context, input OutputService6TestShapeOutputService6TestCaseOperation1Input, opts ...request.Option) (OutputService6TestShapeOutputService6TestCaseOperation1Output, error) { req, out := c.OutputService6TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService6TestShapeOutputService6TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService6TestShapeOutputService6TestCaseOperation1Output struct { _ struct{} `type:"structure"` StrType string `type:"string"` } // SetStrType sets the StrType field's value. func (s OutputService6TestShapeOutputService6TestCaseOperation1Output) SetStrType(v string) OutputService6TestShapeOutputService6TestCaseOperation1Output { s.StrType = &v return s } // OutputService7ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService7ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService7ProtocolTest struct { client.Client } // New creates a new instance of the OutputService7ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a OutputService7ProtocolTest client from just a session. // svc := outputservice7protocoltest.New(mySession) // // // Create a OutputService7ProtocolTest client with additional configuration // svc := outputservice7protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService7ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService7ProtocolTest { c := p.ClientConfig("outputservice7protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService7ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newOutputService7ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService7ProtocolTest { svc := &OutputService7ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService7ProtocolTest", ServiceID: "OutputService7ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService7ProtocolTest operation and runs any // custom request initialization. func (c OutputService7ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService7TestCaseOperation1 = "OperationName" // OutputService7TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService7TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See OutputService7TestCaseOperation1 for more information on using the OutputService7TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the OutputService7TestCaseOperation1Request method. // req, resp := client.OutputService7TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService7ProtocolTest) OutputService7TestCaseOperation1Request(input OutputService7TestShapeOutputService7TestCaseOperation1Input) (req request.Request, output OutputService7TestShapeOutputService7TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService7TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &OutputService7TestShapeOutputService7TestCaseOperation1Input{} } output = &OutputService7TestShapeOutputService7TestCaseOperation1Output{} req = c.newRequest(op, input, output) return } // OutputService7TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation OutputService7TestCaseOperation1 for usage and error information. func (c OutputService7ProtocolTest) OutputService7TestCaseOperation1(input OutputService7TestShapeOutputService7TestCaseOperation1Input) (OutputService7TestShapeOutputService7TestCaseOperation1Output, error) { req, out := c.OutputService7TestCaseOperation1Request(input) return out, req.Send() } // OutputService7TestCaseOperation1WithContext is the same as OutputService7TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService7TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c OutputService7ProtocolTest) OutputService7TestCaseOperation1WithContext(ctx aws.Context, input OutputService7TestShapeOutputService7TestCaseOperation1Input, opts ...request.Option) (OutputService7TestShapeOutputService7TestCaseOperation1Output, error) { req, out := c.OutputService7TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService7TestShapeOutputService7TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService7TestShapeOutputService7TestCaseOperation1Output struct { _ struct{} `type:"structure"` FooEnum string `type:"string" enum:"OutputService7TestShapeJSONEnumType"` ListEnums []string `type:"list" enum:"OutputService7TestShapeJSONEnumType"` } // SetFooEnum sets the FooEnum field's value. func (s OutputService7TestShapeOutputService7TestCaseOperation1Output) SetFooEnum(v string) OutputService7TestShapeOutputService7TestCaseOperation1Output { s.FooEnum = &v return s } // SetListEnums sets the ListEnums field's value. func (s OutputService7TestShapeOutputService7TestCaseOperation1Output) SetListEnums(v []string) OutputService7TestShapeOutputService7TestCaseOperation1Output { s.ListEnums = v return s } const ( // JSONEnumTypeFoo is a OutputService7TestShapeJSONEnumType enum value JSONEnumTypeFoo = "foo" // JSONEnumTypeBar is a OutputService7TestShapeJSONEnumType enum value JSONEnumTypeBar = "bar" ) // OutputService7TestShapeJSONEnumType_Values returns all elements of the OutputService7TestShapeJSONEnumType enum func OutputService7TestShapeJSONEnumType_Values() []string { return []string{ JSONEnumTypeFoo, JSONEnumTypeBar, } } // OutputService8ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService8ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService8ProtocolTest struct { client.Client } // New creates a new instance of the OutputService8ProtocolTest client with a session. // If additional configuration is needed for the client instance use the optional // aws.Config parameter to add your extra config. // // Example: // // mySession := session.Must(session.NewSession()) // // // Create a OutputService8ProtocolTest client from just a session. // svc := outputservice8protocoltest.New(mySession) // // // Create a OutputService8ProtocolTest client with additional configuration // svc := outputservice8protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService8ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService8ProtocolTest { c := p.ClientConfig("outputservice8protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService8ProtocolTestClient(c.Config, c.Handlers, c.PartitionID, c.Endpoint, c.SigningRegion, c.SigningName, c.ResolvedRegion) } // newClient creates, initializes and returns a new service client instance. func newOutputService8ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService8ProtocolTest { svc := &OutputService8ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService8ProtocolTest", ServiceID: "OutputService8ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(jsonrpc.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(jsonrpc.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(jsonrpc.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(jsonrpc.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService8ProtocolTest operation and runs any // custom request initialization. func (c OutputService8ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService8TestCaseOperation1 = "OperationName" // OutputService8TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService8TestCaseOperation1 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See OutputService8TestCaseOperation1 for more information on using the OutputService8TestCaseOperation1 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the OutputService8TestCaseOperation1Request method. // req, resp := client.OutputService8TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService8ProtocolTest) OutputService8TestCaseOperation1Request(input OutputService8TestShapeOutputService8TestCaseOperation1Input) (req request.Request, output OutputService8TestShapeOutputService8TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService8TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &OutputService8TestShapeOutputService8TestCaseOperation1Input{} } output = &OutputService8TestShapeOutputService8TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // OutputService8TestCaseOperation1 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation OutputService8TestCaseOperation1 for usage and error information. func (c OutputService8ProtocolTest) OutputService8TestCaseOperation1(input OutputService8TestShapeOutputService8TestCaseOperation1Input) (OutputService8TestShapeOutputService8TestCaseOperation1Output, error) { req, out := c.OutputService8TestCaseOperation1Request(input) return out, req.Send() } // OutputService8TestCaseOperation1WithContext is the same as OutputService8TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService8TestCaseOperation1 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c OutputService8ProtocolTest) OutputService8TestCaseOperation1WithContext(ctx aws.Context, input OutputService8TestShapeOutputService8TestCaseOperation1Input, opts ...request.Option) (OutputService8TestShapeOutputService8TestCaseOperation1Output, error) { req, out := c.OutputService8TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opOutputService8TestCaseOperation2 = "OperationName" // OutputService8TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the OutputService8TestCaseOperation2 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See OutputService8TestCaseOperation2 for more information on using the OutputService8TestCaseOperation2 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the OutputService8TestCaseOperation2Request method. // req, resp := client.OutputService8TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService8ProtocolTest) OutputService8TestCaseOperation2Request(input OutputService8TestShapeOutputService8TestCaseOperation2Input) (req request.Request, output OutputService8TestShapeOutputService8TestCaseOperation2Output) { op := &request.Operation{ Name: opOutputService8TestCaseOperation2, HTTPPath: "/", } if input == nil { input = &OutputService8TestShapeOutputService8TestCaseOperation2Input{} } output = &OutputService8TestShapeOutputService8TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // OutputService8TestCaseOperation2 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation OutputService8TestCaseOperation2 for usage and error information. func (c OutputService8ProtocolTest) OutputService8TestCaseOperation2(input OutputService8TestShapeOutputService8TestCaseOperation2Input) (OutputService8TestShapeOutputService8TestCaseOperation2Output, error) { req, out := c.OutputService8TestCaseOperation2Request(input) return out, req.Send() } // OutputService8TestCaseOperation2WithContext is the same as OutputService8TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See OutputService8TestCaseOperation2 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c OutputService8ProtocolTest) OutputService8TestCaseOperation2WithContext(ctx aws.Context, input OutputService8TestShapeOutputService8TestCaseOperation2Input, opts ...request.Option) (OutputService8TestShapeOutputService8TestCaseOperation2Output, error) { req, out := c.OutputService8TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opOutputService8TestCaseOperation3 = "OperationName" // OutputService8TestCaseOperation3Request generates a "aws/request.Request" representing the // client's request for the OutputService8TestCaseOperation3 operation. The "output" return // value will be populated with the request's response once the request completes // successfully. // // Use "Send" method on the returned Request to send the API call to the service. // the "output" return value is not valid until after Send returns without error. // // See OutputService8TestCaseOperation3 for more information on using the OutputService8TestCaseOperation3 // API call, and error handling. // // This method is useful when you want to inject custom logic or configuration // into the SDK's request lifecycle. Such as custom headers, or retry logic. // // // Example sending a request using the OutputService8TestCaseOperation3Request method. // req, resp := client.OutputService8TestCaseOperation3Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService8ProtocolTest) OutputService8TestCaseOperation3Request(input OutputService8TestShapeOutputService8TestCaseOperation3Input) (req request.Request, output OutputService8TestShapeOutputService8TestCaseOperation3Output) { op := &request.Operation{ Name: opOutputService8TestCaseOperation3, HTTPPath: "/", } if input == nil { input = &OutputService8TestShapeOutputService8TestCaseOperation3Input{} } output = &OutputService8TestShapeOutputService8TestCaseOperation3Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(jsonrpc.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // OutputService8TestCaseOperation3 API operation for . // // Returns awserr.Error for service API and SDK errors. Use runtime type assertions // with awserr.Error's Code and Message methods to get detailed information about // the error. // // See the AWS API reference guide for 's // API operation OutputService8TestCaseOperation3 for usage and error information. func (c OutputService8ProtocolTest) OutputService8TestCaseOperation3(input OutputService8TestShapeOutputService8TestCaseOperation3Input) (OutputService8TestShapeOutputService8TestCaseOperation3Output, error) { req, out := c.OutputService8TestCaseOperation3Request(input) return out, req.Send() } // OutputService8TestCaseOperation3WithContext is the same as OutputService8TestCaseOperation3 with the addition of // the ability to pass a context and additional request options. // // See OutputService8TestCaseOperation3 for details on how to use this API operation. // // The context must be non-nil and will be used for request cancellation. If // the context is nil a panic will occur. In the future the SDK may create // sub-contexts for http.Requests. See https://golang.org/pkg/context/ // for more information on using Contexts. func (c OutputService8ProtocolTest) OutputService8TestCaseOperation3WithContext(ctx aws.Context, input OutputService8TestShapeOutputService8TestCaseOperation3Input, opts ...request.Option) (OutputService8TestShapeOutputService8TestCaseOperation3Output, error) { req, out := c.OutputService8TestCaseOperation3Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService8TestShapeOutputService8TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService8TestShapeOutputService8TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type OutputService8TestShapeOutputService8TestCaseOperation2Input struct { _ struct{} `type:"structure"` } type OutputService8TestShapeOutputService8TestCaseOperation2Output struct { _ struct{} `type:"structure"` } type OutputService8TestShapeOutputService8TestCaseOperation3Input struct { _ struct{} `type:"structure"` } type OutputService8TestShapeOutputService8TestCaseOperation3Output struct { _ struct{} `type:"structure"` } // // Tests begin here // func TestOutputService1ProtocolTestScalarMembersCase1(t testing.T) { svc := NewOutputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"Str\": \"myname\", \"Num\": 123, \"FalseBool\": false, \"TrueBool\": true, \"Float\": 1.2, \"Double\": 1.3, \"Long\": 200, \"Char\": \"a\"}")) req, out := svc.OutputService1TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response req.Handlers.UnmarshalMeta.Run(req) req.Handlers.Unmarshal.Run(req) if req.Error != nil { t.Errorf("expect not error, got %v", req.Error) } // assert response if out == nil { t.Errorf("expect not to be nil") } if e, a := "a", out.Char; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := 1.3, out.Double; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := false, out.FalseBool; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := 1.2, out.Float; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := int64(200), out.Long; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := int64(123), out.Num; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "myname", out.Str; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := true, out.TrueBool; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService2ProtocolTestBlobMembersCase1(t testing.T) { svc := NewOutputService2ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"BlobMember\": \"aGkh\", \"StructMember\": {\"foo\": \"dGhlcmUh\"}}")) req, out := svc.OutputService2TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response req.Handlers.UnmarshalMeta.Run(req) req.Handlers.Unmarshal.Run(req) if req.Error != nil { t.Errorf("expect not error, got %v", req.Error) } // assert response if out == nil { t.Errorf("expect not to be nil") } if e, a := "hi!", string(out.BlobMember); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "there!", string(out.StructMember.Foo); e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService3ProtocolTestTimestampMembersCase1(t testing.T) { svc := NewOutputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"TimeArg\": 1398796238, \"TimeCustom\": \"Tue, 29 Apr 2014 18:30:38 GMT\", \"TimeFormat\": \"2014-04-29T18:30:38Z\", \"StructMember\": {\"foo\": 1398796238, \"bar\": \"2014-04-29T18:30:38Z\"}}")) req, out := svc.OutputService3TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response req.Handlers.UnmarshalMeta.Run(req) req.Handlers.Unmarshal.Run(req) if req.Error != nil { t.Errorf("expect not error, got %v", req.Error) } // assert response if out == nil { t.Errorf("expect not to be nil") } if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.StructMember.Bar.UTC().String(); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.StructMember.Foo.UTC().String(); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.TimeArg.UTC().String(); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.TimeCustom.UTC().String(); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.TimeFormat.UTC().String(); e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService4ProtocolTestListsCase1(t testing.T) { svc := NewOutputService4ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"ListMember\": [\"a\", \"b\"]}")) req, out := svc.OutputService4TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response req.Handlers.UnmarshalMeta.Run(req) req.Handlers.Unmarshal.Run(req) if req.Error != nil { t.Errorf("expect not error, got %v", req.Error) } // assert response if out == nil { t.Errorf("expect not to be nil") } if e, a := "a", out.ListMember[0]; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "b", out.ListMember[1]; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService4ProtocolTestListsCase2(t testing.T) { svc := NewOutputService4ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"ListMember\": [\"a\", null], \"ListMemberMap\": [{}, null, null, {}], \"ListMemberStruct\": [{}, null, null, {}]}")) req, out := svc.OutputService4TestCaseOperation2Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response req.Handlers.UnmarshalMeta.Run(req) req.Handlers.Unmarshal.Run(req) if req.Error != nil { t.Errorf("expect not error, got %v", req.Error) } // assert response if out == nil { t.Errorf("expect not to be nil") } if e, a := "a", out.ListMember[0]; e != a { t.Errorf("expect %v, got %v", e, a) } if e := out.ListMember[1]; e != nil { t.Errorf("expect nil, got %v", e) } if e := out.ListMemberMap[1]; e != nil { t.Errorf("expect nil, got %v", e) } if e := out.ListMemberMap[2]; e != nil { t.Errorf("expect nil, got %v", e) } if e := out.ListMemberStruct[1]; e != nil { t.Errorf("expect nil, got %v", e) } if e := out.ListMemberStruct[2]; e != nil { t.Errorf("expect nil, got %v", e) } } func TestOutputService5ProtocolTestMapsCase1(t testing.T) { svc := NewOutputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"MapMember\": {\"a\": [1, 2], \"b\": [3, 4]}}")) req, out := svc.OutputService5TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response req.Handlers.UnmarshalMeta.Run(req) req.Handlers.Unmarshal.Run(req) if req.Error != nil { t.Errorf("expect not error, got %v", req.Error) } // assert response if out == nil { t.Errorf("expect not to be nil") } if e, a := int64(1), out.MapMember["a"][0]; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := int64(2), out.MapMember["a"][1]; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := int64(3), out.MapMember["b"][0]; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := int64(4), out.MapMember["b"][1]; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService6ProtocolTestIgnoresExtraDataCase1(t testing.T) { svc := NewOutputService6ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"foo\": \"bar\"}")) req, out := svc.OutputService6TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response req.Handlers.UnmarshalMeta.Run(req) req.Handlers.Unmarshal.Run(req) if req.Error != nil { t.Errorf("expect not error, got %v", req.Error) } // assert response if out == nil { t.Errorf("expect not to be nil") } } func TestOutputService7ProtocolTestEnumOutputCase1(t testing.T) { svc := NewOutputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{\"FooEnum\": \"foo\", \"ListEnums\": [\"foo\", \"bar\"]}")) req, out := svc.OutputService7TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response req.Handlers.UnmarshalMeta.Run(req) req.Handlers.Unmarshal.Run(req) if req.Error != nil { t.Errorf("expect not error, got %v", req.Error) } // assert response if out == nil { t.Errorf("expect not to be nil") } if e, a := "foo", out.FooEnum; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "foo", out.ListEnums[0]; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "bar", out.ListEnums[1]; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService8ProtocolTestunmodeledNonjsonResponsePayloadCase1(t testing.T) { svc := NewOutputService8ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("success")) req, out := svc.OutputService8TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response req.Handlers.UnmarshalMeta.Run(req) req.Handlers.Unmarshal.Run(req) if req.Error != nil { t.Errorf("expect not error, got %v", req.Error) } // assert response if out == nil { t.Errorf("expect not to be nil") } } func TestOutputService8ProtocolTestunmodeledNonjsonResponsePayloadCase2(t testing.T) { svc := NewOutputService8ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("\"success\"")) req, out := svc.OutputService8TestCaseOperation2Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response req.Handlers.UnmarshalMeta.Run(req) req.Handlers.Unmarshal.Run(req) if req.Error != nil { t.Errorf("expect not error, got %v", req.Error) } // assert response if out == nil { t.Errorf("expect not to be nil") } } func TestOutputService8ProtocolTestunmodeledNonjsonResponsePayloadCase3(t testing.T) { svc := NewOutputService8ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("{}")) req, out := svc.OutputService8TestCaseOperation3Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response req.Handlers.UnmarshalMeta.Run(req) req.Handlers.Unmarshal.Run(req) if req.Error != nil { t.Errorf("expect not error, got %v", req.Error) } // assert response if out == nil { t.Errorf("expect not to be nil") } }	78.11 KB	2025-05-25 12:27

Terminal