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 restxml_test import ( "net/http" "net/http/httptest" "os" "testing" "bytes" "encoding/xml" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/credentials" "github.com/aws/aws-sdk-go/aws/endpoints" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/private/protocol/restxml" "github.com/aws/aws-sdk-go/service/cloudfront" "github.com/aws/aws-sdk-go/service/s3" ) var ( cloudfrontSvc cloudfront.CloudFront s3Svc s3.S3 ) func TestMain(m testing.M) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { w.WriteHeader(http.StatusOK) })) sess := session.Must(session.NewSession(&aws.Config{ Credentials: credentials.NewStaticCredentials("Key", "Secret", "Token"), Endpoint: aws.String(server.URL), S3ForcePathStyle: aws.Bool(true), DisableSSL: aws.Bool(true), Region: aws.String(endpoints.UsWest2RegionID), })) cloudfrontSvc = cloudfront.New(sess) s3Svc = s3.New(sess) c := m.Run() server.Close() os.Exit(c) } func BenchmarkRESTXMLBuild_Complex_CFCreateDistro(b testing.B) { params := cloudfrontCreateDistributionInput() benchRESTXMLBuild(b, func() request.Request { req, _ := cloudfrontSvc.CreateDistributionRequest(params) return req }) } func BenchmarkRESTXMLBuild_Simple_CFDeleteDistro(b testing.B) { params := cloudfrontDeleteDistributionInput() benchRESTXMLBuild(b, func() request.Request { req, _ := cloudfrontSvc.DeleteDistributionRequest(params) return req }) } func BenchmarkRESTXMLBuild_REST_S3HeadObject(b testing.B) { params := s3HeadObjectInput() benchRESTXMLBuild(b, func() request.Request { req, _ := s3Svc.HeadObjectRequest(params) return req }) } func BenchmarkRESTXMLBuild_XML_S3PutObjectAcl(b testing.B) { params := s3PutObjectAclInput() benchRESTXMLBuild(b, func() request.Request { req, _ := s3Svc.PutObjectAclRequest(params) return req }) } func BenchmarkRESTXMLRequest_Complex_CFCreateDistro(b testing.B) { benchRESTXMLRequest(b, func() request.Request { req, _ := cloudfrontSvc.CreateDistributionRequest(cloudfrontCreateDistributionInput()) return req }) } func BenchmarkRESTXMLRequest_Simple_CFDeleteDistro(b testing.B) { benchRESTXMLRequest(b, func() request.Request { req, _ := cloudfrontSvc.DeleteDistributionRequest(cloudfrontDeleteDistributionInput()) return req }) } func BenchmarkRESTXMLRequest_REST_S3HeadObject(b testing.B) { benchRESTXMLRequest(b, func() request.Request { req, _ := s3Svc.HeadObjectRequest(s3HeadObjectInput()) return req }) } func BenchmarkRESTXMLRequest_XML_S3PutObjectAcl(b testing.B) { benchRESTXMLRequest(b, func() request.Request { req, _ := s3Svc.PutObjectAclRequest(s3PutObjectAclInput()) return req }) } func BenchmarkEncodingXML_Simple(b testing.B) { params := cloudfrontDeleteDistributionInput() for i := 0; i < b.N; i++ { buf := &bytes.Buffer{} encoder := xml.NewEncoder(buf) if err := encoder.Encode(params); err != nil { b.Fatal("Unexpected error", err) } } } func benchRESTXMLBuild(b testing.B, reqFn func() request.Request) { b.ResetTimer() for i := 0; i < b.N; i++ { req := reqFn() restxml.Build(req) if req.Error != nil { b.Fatal("Unexpected error", req.Error) } } } func benchRESTXMLRequest(b testing.B, reqFn func() request.Request) { b.ResetTimer() for i := 0; i < b.N; i++ { err := reqFn().Send() if err != nil { b.Fatal("Unexpected error", err) } } } func cloudfrontCreateDistributionInput() cloudfront.CreateDistributionInput { return &cloudfront.CreateDistributionInput{ DistributionConfig: &cloudfront.DistributionConfig{ // Required CallerReference: aws.String("string"), // Required Comment: aws.String("string"), // Required DefaultCacheBehavior: &cloudfront.DefaultCacheBehavior{ // Required ForwardedValues: &cloudfront.ForwardedValues{ // Required Cookies: &cloudfront.CookiePreference{ // Required Forward: aws.String("ItemSelection"), // Required WhitelistedNames: &cloudfront.CookieNames{ Quantity: aws.Int64(1), // Required Items: []string{ aws.String("string"), // Required // More values... }, }, }, QueryString: aws.Bool(true), // Required Headers: &cloudfront.Headers{ Quantity: aws.Int64(1), // Required Items: []string{ aws.String("string"), // Required // More values... }, }, }, MinTTL: aws.Int64(1), // Required TargetOriginId: aws.String("string"), // Required TrustedSigners: &cloudfront.TrustedSigners{ // Required Enabled: aws.Bool(true), // Required Quantity: aws.Int64(1), // Required Items: []string{ aws.String("string"), // Required // More values... }, }, ViewerProtocolPolicy: aws.String("ViewerProtocolPolicy"), // Required AllowedMethods: &cloudfront.AllowedMethods{ Items: []string{ // Required aws.String("Method"), // Required // More values... }, Quantity: aws.Int64(1), // Required CachedMethods: &cloudfront.CachedMethods{ Items: []string{ // Required aws.String("Method"), // Required // More values... }, Quantity: aws.Int64(1), // Required }, }, DefaultTTL: aws.Int64(1), MaxTTL: aws.Int64(1), SmoothStreaming: aws.Bool(true), }, Enabled: aws.Bool(true), // Required Origins: &cloudfront.Origins{ // Required Quantity: aws.Int64(1), // Required Items: []cloudfront.Origin{ { // Required DomainName: aws.String("string"), // Required Id: aws.String("string"), // Required CustomOriginConfig: &cloudfront.CustomOriginConfig{ HTTPPort: aws.Int64(1), // Required HTTPSPort: aws.Int64(1), // Required OriginProtocolPolicy: aws.String("OriginProtocolPolicy"), // Required }, OriginPath: aws.String("string"), S3OriginConfig: &cloudfront.S3OriginConfig{ OriginAccessIdentity: aws.String("string"), // Required }, }, // More values... }, }, Aliases: &cloudfront.Aliases{ Quantity: aws.Int64(1), // Required Items: []string{ aws.String("string"), // Required // More values... }, }, CacheBehaviors: &cloudfront.CacheBehaviors{ Quantity: aws.Int64(1), // Required Items: []cloudfront.CacheBehavior{ { // Required ForwardedValues: &cloudfront.ForwardedValues{ // Required Cookies: &cloudfront.CookiePreference{ // Required Forward: aws.String("ItemSelection"), // Required WhitelistedNames: &cloudfront.CookieNames{ Quantity: aws.Int64(1), // Required Items: []string{ aws.String("string"), // Required // More values... }, }, }, QueryString: aws.Bool(true), // Required Headers: &cloudfront.Headers{ Quantity: aws.Int64(1), // Required Items: []string{ aws.String("string"), // Required // More values... }, }, }, MinTTL: aws.Int64(1), // Required PathPattern: aws.String("string"), // Required TargetOriginId: aws.String("string"), // Required TrustedSigners: &cloudfront.TrustedSigners{ // Required Enabled: aws.Bool(true), // Required Quantity: aws.Int64(1), // Required Items: []string{ aws.String("string"), // Required // More values... }, }, ViewerProtocolPolicy: aws.String("ViewerProtocolPolicy"), // Required AllowedMethods: &cloudfront.AllowedMethods{ Items: []string{ // Required aws.String("Method"), // Required // More values... }, Quantity: aws.Int64(1), // Required CachedMethods: &cloudfront.CachedMethods{ Items: []string{ // Required aws.String("Method"), // Required // More values... }, Quantity: aws.Int64(1), // Required }, }, DefaultTTL: aws.Int64(1), MaxTTL: aws.Int64(1), SmoothStreaming: aws.Bool(true), }, // More values... }, }, CustomErrorResponses: &cloudfront.CustomErrorResponses{ Quantity: aws.Int64(1), // Required Items: []cloudfront.CustomErrorResponse{ { // Required ErrorCode: aws.Int64(1), // Required ErrorCachingMinTTL: aws.Int64(1), ResponseCode: aws.String("string"), ResponsePagePath: aws.String("string"), }, // More values... }, }, DefaultRootObject: aws.String("string"), Logging: &cloudfront.LoggingConfig{ Bucket: aws.String("string"), // Required Enabled: aws.Bool(true), // Required IncludeCookies: aws.Bool(true), // Required Prefix: aws.String("string"), // Required }, PriceClass: aws.String("PriceClass"), Restrictions: &cloudfront.Restrictions{ GeoRestriction: &cloudfront.GeoRestriction{ // Required Quantity: aws.Int64(1), // Required RestrictionType: aws.String("GeoRestrictionType"), // Required Items: []string{ aws.String("string"), // Required // More values... }, }, }, ViewerCertificate: &cloudfront.ViewerCertificate{ CloudFrontDefaultCertificate: aws.Bool(true), IAMCertificateId: aws.String("string"), MinimumProtocolVersion: aws.String("MinimumProtocolVersion"), SSLSupportMethod: aws.String("SSLSupportMethod"), }, }, } } func cloudfrontDeleteDistributionInput() cloudfront.DeleteDistributionInput { return &cloudfront.DeleteDistributionInput{ Id: aws.String("string"), // Required IfMatch: aws.String("string"), } } func s3HeadObjectInput() s3.HeadObjectInput { return &s3.HeadObjectInput{ Bucket: aws.String("somebucketname"), Key: aws.String("keyname"), VersionId: aws.String("someVersion"), IfMatch: aws.String("IfMatch"), } } func s3PutObjectAclInput() s3.PutObjectAclInput { return &s3.PutObjectAclInput{ Bucket: aws.String("somebucketname"), Key: aws.String("keyname"), AccessControlPolicy: &s3.AccessControlPolicy{ Grants: []*s3.Grant{ { Grantee: &s3.Grantee{ DisplayName: aws.String("someName"), EmailAddress: aws.String("someAddr"), ID: aws.String("someID"), Type: aws.String(s3.TypeCanonicalUser), URI: aws.String("someURI"), }, Permission: aws.String(s3.PermissionWrite), }, }, Owner: &s3.Owner{ DisplayName: aws.String("howdy"), ID: aws.String("someID"), }, }, } }	10.67 KB	2025-05-25 12:27
📄 build_test.go // Code generated by models/protocol_tests/generate.go. DO NOT EDIT. package restxml_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/restxml" "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: "2014-01-01", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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: "/2014-01-01/hostedzone", } if input == nil { input = &InputService1TestShapeInputService1TestCaseOperation1Input{} } output = &InputService1TestShapeInputService1TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.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() } const opInputService1TestCaseOperation2 = "OperationName" // InputService1TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the InputService1TestCaseOperation2 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 InputService1TestCaseOperation2 for more information on using the InputService1TestCaseOperation2 // 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 InputService1TestCaseOperation2Request method. // req, resp := client.InputService1TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService1ProtocolTest) InputService1TestCaseOperation2Request(input InputService1TestShapeInputService1TestCaseOperation2Input) (req request.Request, output InputService1TestShapeInputService1TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService1TestCaseOperation2, HTTPMethod: "PUT", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService1TestShapeInputService1TestCaseOperation2Input{} } output = &InputService1TestShapeInputService1TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService1TestCaseOperation2 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 InputService1TestCaseOperation2 for usage and error information. func (c InputService1ProtocolTest) InputService1TestCaseOperation2(input InputService1TestShapeInputService1TestCaseOperation2Input) (InputService1TestShapeInputService1TestCaseOperation2Output, error) { req, out := c.InputService1TestCaseOperation2Request(input) return out, req.Send() } // InputService1TestCaseOperation2WithContext is the same as InputService1TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See InputService1TestCaseOperation2 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) InputService1TestCaseOperation2WithContext(ctx aws.Context, input InputService1TestShapeInputService1TestCaseOperation2Input, opts ...request.Option) (InputService1TestShapeInputService1TestCaseOperation2Output, error) { req, out := c.InputService1TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService1TestCaseOperation3 = "OperationName" // InputService1TestCaseOperation3Request generates a "aws/request.Request" representing the // client's request for the InputService1TestCaseOperation3 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 InputService1TestCaseOperation3 for more information on using the InputService1TestCaseOperation3 // 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 InputService1TestCaseOperation3Request method. // req, resp := client.InputService1TestCaseOperation3Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService1ProtocolTest) InputService1TestCaseOperation3Request(input InputService1TestShapeInputService1TestCaseOperation3Input) (req request.Request, output InputService1TestShapeInputService1TestCaseOperation3Output) { op := &request.Operation{ Name: opInputService1TestCaseOperation3, HTTPMethod: "GET", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService1TestShapeInputService1TestCaseOperation3Input{} } output = &InputService1TestShapeInputService1TestCaseOperation3Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService1TestCaseOperation3 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 InputService1TestCaseOperation3 for usage and error information. func (c InputService1ProtocolTest) InputService1TestCaseOperation3(input InputService1TestShapeInputService1TestCaseOperation3Input) (InputService1TestShapeInputService1TestCaseOperation3Output, error) { req, out := c.InputService1TestCaseOperation3Request(input) return out, req.Send() } // InputService1TestCaseOperation3WithContext is the same as InputService1TestCaseOperation3 with the addition of // the ability to pass a context and additional request options. // // See InputService1TestCaseOperation3 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) InputService1TestCaseOperation3WithContext(ctx aws.Context, input InputService1TestShapeInputService1TestCaseOperation3Input, opts ...request.Option) (InputService1TestShapeInputService1TestCaseOperation3Output, error) { req, out := c.InputService1TestCaseOperation3Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService1TestShapeInputService1TestCaseOperation1Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` Description string `type:"string"` Name string `type:"string"` } // SetDescription sets the Description field's value. func (s InputService1TestShapeInputService1TestCaseOperation1Input) SetDescription(v string) InputService1TestShapeInputService1TestCaseOperation1Input { s.Description = &v return s } // 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"` } type InputService1TestShapeInputService1TestCaseOperation2Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` Description string `type:"string"` Name string `type:"string"` } // SetDescription sets the Description field's value. func (s InputService1TestShapeInputService1TestCaseOperation2Input) SetDescription(v string) InputService1TestShapeInputService1TestCaseOperation2Input { s.Description = &v return s } // SetName sets the Name field's value. func (s InputService1TestShapeInputService1TestCaseOperation2Input) SetName(v string) InputService1TestShapeInputService1TestCaseOperation2Input { s.Name = &v return s } type InputService1TestShapeInputService1TestCaseOperation2Output struct { _ struct{} `type:"structure"` } type InputService1TestShapeInputService1TestCaseOperation3Input struct { _ struct{} `type:"structure"` } type InputService1TestShapeInputService1TestCaseOperation3Output 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: "2014-01-01", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService2TestShapeInputService2TestCaseOperation1Input{} } output = &InputService2TestShapeInputService2TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.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{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` First bool `type:"boolean"` Fourth int64 `type:"integer"` Second bool `type:"boolean"` Third float64 `type:"float"` } // SetFirst sets the First field's value. func (s InputService2TestShapeInputService2TestCaseOperation1Input) SetFirst(v bool) InputService2TestShapeInputService2TestCaseOperation1Input { s.First = &v return s } // SetFourth sets the Fourth field's value. func (s InputService2TestShapeInputService2TestCaseOperation1Input) SetFourth(v int64) InputService2TestShapeInputService2TestCaseOperation1Input { s.Fourth = &v return s } // SetSecond sets the Second field's value. func (s InputService2TestShapeInputService2TestCaseOperation1Input) SetSecond(v bool) InputService2TestShapeInputService2TestCaseOperation1Input { s.Second = &v return s } // SetThird sets the Third field's value. func (s InputService2TestShapeInputService2TestCaseOperation1Input) SetThird(v float64) InputService2TestShapeInputService2TestCaseOperation1Input { s.Third = &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: "2014-01-01", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService3TestShapeInputService3TestCaseOperation1Input{} } output = &InputService3TestShapeInputService3TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.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, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService3TestShapeInputService3TestCaseOperation2Input{} } output = &InputService3TestShapeInputService3TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.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{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` Description string `type:"string"` SubStructure InputService3TestShapeSubStructure `type:"structure"` } // SetDescription sets the Description field's value. func (s InputService3TestShapeInputService3TestCaseOperation1Input) SetDescription(v string) InputService3TestShapeInputService3TestCaseOperation1Input { s.Description = &v return s } // SetSubStructure sets the SubStructure field's value. func (s InputService3TestShapeInputService3TestCaseOperation1Input) SetSubStructure(v InputService3TestShapeSubStructure) InputService3TestShapeInputService3TestCaseOperation1Input { s.SubStructure = v return s } type InputService3TestShapeInputService3TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService3TestShapeInputService3TestCaseOperation2Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` Description string `type:"string"` SubStructure InputService3TestShapeSubStructure `type:"structure"` } // SetDescription sets the Description field's value. func (s InputService3TestShapeInputService3TestCaseOperation2Input) SetDescription(v string) InputService3TestShapeInputService3TestCaseOperation2Input { s.Description = &v return s } // SetSubStructure sets the SubStructure field's value. func (s InputService3TestShapeInputService3TestCaseOperation2Input) SetSubStructure(v InputService3TestShapeSubStructure) InputService3TestShapeInputService3TestCaseOperation2Input { s.SubStructure = v return s } type InputService3TestShapeInputService3TestCaseOperation2Output struct { _ struct{} `type:"structure"` } type InputService3TestShapeSubStructure struct { _ struct{} `type:"structure"` Bar string `type:"string"` Foo string `type:"string"` } // SetBar sets the Bar field's value. func (s InputService3TestShapeSubStructure) SetBar(v string) InputService3TestShapeSubStructure { s.Bar = &v return s } // SetFoo sets the Foo field's value. func (s InputService3TestShapeSubStructure) SetFoo(v string) InputService3TestShapeSubStructure { s.Foo = &v return s } // 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: "2014-01-01", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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: "/2014-01-01/hostedzone", } if input == nil { input = &InputService4TestShapeInputService4TestCaseOperation1Input{} } output = &InputService4TestShapeInputService4TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.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{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` Description string `type:"string"` SubStructure InputService4TestShapeSubStructure `type:"structure"` } // SetDescription sets the Description field's value. func (s InputService4TestShapeInputService4TestCaseOperation1Input) SetDescription(v string) InputService4TestShapeInputService4TestCaseOperation1Input { s.Description = &v return s } // SetSubStructure sets the SubStructure field's value. func (s InputService4TestShapeInputService4TestCaseOperation1Input) SetSubStructure(v InputService4TestShapeSubStructure) InputService4TestShapeInputService4TestCaseOperation1Input { s.SubStructure = v return s } type InputService4TestShapeInputService4TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService4TestShapeSubStructure struct { _ struct{} `type:"structure"` Bar string `type:"string"` Foo string `type:"string"` } // SetBar sets the Bar field's value. func (s InputService4TestShapeSubStructure) SetBar(v string) InputService4TestShapeSubStructure { s.Bar = &v return s } // SetFoo sets the Foo field's value. func (s InputService4TestShapeSubStructure) SetFoo(v string) InputService4TestShapeSubStructure { s.Foo = &v return s } // 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: "2014-01-01", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService5TestShapeInputService5TestCaseOperation1Input{} } output = &InputService5TestShapeInputService5TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.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() } type InputService5TestShapeInputService5TestCaseOperation1Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` ListParam []string `type:"list"` } // SetListParam sets the ListParam field's value. func (s InputService5TestShapeInputService5TestCaseOperation1Input) SetListParam(v []string) InputService5TestShapeInputService5TestCaseOperation1Input { s.ListParam = v return s } type InputService5TestShapeInputService5TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // 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: "2014-01-01", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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: "/2014-01-01/hostedzone", } if input == nil { input = &InputService6TestShapeInputService6TestCaseOperation1Input{} } output = &InputService6TestShapeInputService6TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.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{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` ListParam []string `locationName:"AlternateName" locationNameList:"NotMember" type:"list"` } // SetListParam sets the ListParam field's value. func (s InputService6TestShapeInputService6TestCaseOperation1Input) SetListParam(v []string) InputService6TestShapeInputService6TestCaseOperation1Input { s.ListParam = 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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: "/2014-01-01/hostedzone", } if input == nil { input = &InputService7TestShapeInputService7TestCaseOperation1Input{} } output = &InputService7TestShapeInputService7TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.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() } type InputService7TestShapeInputService7TestCaseOperation1Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` ListParam []string `type:"list" flattened:"true"` } // SetListParam sets the ListParam field's value. func (s InputService7TestShapeInputService7TestCaseOperation1Input) SetListParam(v []string) InputService7TestShapeInputService7TestCaseOperation1Input { s.ListParam = v return s } type InputService7TestShapeInputService7TestCaseOperation1Output 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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: "/2014-01-01/hostedzone", } if input == nil { input = &InputService8TestShapeInputService8TestCaseOperation1Input{} } output = &InputService8TestShapeInputService8TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.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() } type InputService8TestShapeInputService8TestCaseOperation1Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` ListParam []string `locationName:"item" type:"list" flattened:"true"` } // SetListParam sets the ListParam field's value. func (s InputService8TestShapeInputService8TestCaseOperation1Input) SetListParam(v []string) InputService8TestShapeInputService8TestCaseOperation1Input { s.ListParam = v return s } type InputService8TestShapeInputService8TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // 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: "2014-01-01", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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 = "OperationName" // 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: "/2014-01-01/hostedzone", } if input == nil { input = &InputService9TestShapeInputService9TestCaseOperation1Input{} } output = &InputService9TestShapeInputService9TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 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() } type InputService9TestShapeInputService9TestCaseOperation1Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` ListParam []InputService9TestShapeSingleFieldStruct `locationName:"item" type:"list" flattened:"true"` } // SetListParam sets the ListParam field's value. func (s InputService9TestShapeInputService9TestCaseOperation1Input) SetListParam(v []InputService9TestShapeSingleFieldStruct) InputService9TestShapeInputService9TestCaseOperation1Input { s.ListParam = v return s } type InputService9TestShapeInputService9TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService9TestShapeSingleFieldStruct struct { _ struct{} `type:"structure"` Element string `locationName:"value" type:"string"` } // SetElement sets the Element field's value. func (s InputService9TestShapeSingleFieldStruct) SetElement(v string) InputService9TestShapeSingleFieldStruct { s.Element = &v return s } // InputService10ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService10ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService10ProtocolTest struct { client.Client } // New creates a new instance of the InputService10ProtocolTest 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 InputService10ProtocolTest client from just a session. // svc := inputservice10protocoltest.New(mySession) // // // Create a InputService10ProtocolTest client with additional configuration // svc := inputservice10protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService10ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService10ProtocolTest { c := p.ClientConfig("inputservice10protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService10ProtocolTestClient(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 newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService10ProtocolTest { svc := &InputService10ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService10ProtocolTest", ServiceID: "InputService10ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService10ProtocolTest operation and runs any // custom request initialization. func (c InputService10ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService10TestCaseOperation1 = "OperationName" // InputService10TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService10TestCaseOperation1 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 InputService10TestCaseOperation1 for more information on using the InputService10TestCaseOperation1 // 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 InputService10TestCaseOperation1Request method. // req, resp := client.InputService10TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService10ProtocolTest) InputService10TestCaseOperation1Request(input InputService10TestShapeInputService10TestCaseOperation1Input) (req request.Request, output InputService10TestShapeInputService10TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService10TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService10TestShapeInputService10TestCaseOperation1Input{} } output = &InputService10TestShapeInputService10TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService10TestCaseOperation1 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 InputService10TestCaseOperation1 for usage and error information. func (c InputService10ProtocolTest) InputService10TestCaseOperation1(input InputService10TestShapeInputService10TestCaseOperation1Input) (InputService10TestShapeInputService10TestCaseOperation1Output, error) { req, out := c.InputService10TestCaseOperation1Request(input) return out, req.Send() } // InputService10TestCaseOperation1WithContext is the same as InputService10TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService10TestCaseOperation1 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 InputService10ProtocolTest) InputService10TestCaseOperation1WithContext(ctx aws.Context, input InputService10TestShapeInputService10TestCaseOperation1Input, opts ...request.Option) (InputService10TestShapeInputService10TestCaseOperation1Output, error) { req, out := c.InputService10TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService10TestShapeInputService10TestCaseOperation1Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` StructureParam InputService10TestShapeStructureShape `type:"structure"` } // SetStructureParam sets the StructureParam field's value. func (s InputService10TestShapeInputService10TestCaseOperation1Input) SetStructureParam(v InputService10TestShapeStructureShape) InputService10TestShapeInputService10TestCaseOperation1Input { s.StructureParam = v return s } type InputService10TestShapeInputService10TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService10TestShapeStructureShape struct { _ struct{} `type:"structure"` // B is automatically base64 encoded/decoded by the SDK. B []byte `locationName:"b" type:"blob"` } // SetB sets the B field's value. func (s InputService10TestShapeStructureShape) SetB(v []byte) InputService10TestShapeStructureShape { s.B = v return s } // InputService11ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService11ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService11ProtocolTest struct { client.Client } // New creates a new instance of the InputService11ProtocolTest 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 InputService11ProtocolTest client from just a session. // svc := inputservice11protocoltest.New(mySession) // // // Create a InputService11ProtocolTest client with additional configuration // svc := inputservice11protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService11ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService11ProtocolTest { c := p.ClientConfig("inputservice11protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService11ProtocolTestClient(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 newInputService11ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService11ProtocolTest { svc := &InputService11ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService11ProtocolTest", ServiceID: "InputService11ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService11ProtocolTest operation and runs any // custom request initialization. func (c InputService11ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService11TestCaseOperation1 = "OperationName" // InputService11TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService11TestCaseOperation1 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 InputService11TestCaseOperation1 for more information on using the InputService11TestCaseOperation1 // 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 InputService11TestCaseOperation1Request method. // req, resp := client.InputService11TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService11ProtocolTest) InputService11TestCaseOperation1Request(input InputService11TestShapeInputService11TestCaseOperation1Input) (req request.Request, output InputService11TestShapeInputService11TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService11TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/2014-01-01/hostedzone", } if input == nil { input = &InputService11TestShapeInputService11TestCaseOperation1Input{} } output = &InputService11TestShapeInputService11TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService11TestCaseOperation1 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 InputService11TestCaseOperation1 for usage and error information. func (c InputService11ProtocolTest) InputService11TestCaseOperation1(input InputService11TestShapeInputService11TestCaseOperation1Input) (InputService11TestShapeInputService11TestCaseOperation1Output, error) { req, out := c.InputService11TestCaseOperation1Request(input) return out, req.Send() } // InputService11TestCaseOperation1WithContext is the same as InputService11TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService11TestCaseOperation1 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 InputService11ProtocolTest) InputService11TestCaseOperation1WithContext(ctx aws.Context, input InputService11TestShapeInputService11TestCaseOperation1Input, opts ...request.Option) (InputService11TestShapeInputService11TestCaseOperation1Output, error) { req, out := c.InputService11TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService11TestShapeInputService11TestCaseOperation1Input struct { _ struct{} `locationName:"TimestampStructure" type:"structure" xmlURI:"https://foo/"` TimeArg time.Time `type:"timestamp"` TimeArgInHeader time.Time `location:"header" locationName:"x-amz-timearg" type:"timestamp"` TimeArgInQuery time.Time `location:"querystring" locationName:"TimeQuery" type:"timestamp"` TimeCustom time.Time `type:"timestamp" timestampFormat:"rfc822"` TimeCustomInHeader time.Time `location:"header" locationName:"x-amz-timecustom-header" type:"timestamp" timestampFormat:"unixTimestamp"` TimeCustomInQuery time.Time `location:"querystring" locationName:"TimeCustomQuery" type:"timestamp" timestampFormat:"unixTimestamp"` TimeFormat time.Time `type:"timestamp" timestampFormat:"rfc822"` TimeFormatInHeader time.Time `location:"header" locationName:"x-amz-timeformat-header" type:"timestamp" timestampFormat:"unixTimestamp"` TimeFormatInQuery time.Time `location:"querystring" locationName:"TimeFormatQuery" type:"timestamp" timestampFormat:"unixTimestamp"` } // SetTimeArg sets the TimeArg field's value. func (s InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeArg(v time.Time) InputService11TestShapeInputService11TestCaseOperation1Input { s.TimeArg = &v return s } // SetTimeArgInHeader sets the TimeArgInHeader field's value. func (s InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeArgInHeader(v time.Time) InputService11TestShapeInputService11TestCaseOperation1Input { s.TimeArgInHeader = &v return s } // SetTimeArgInQuery sets the TimeArgInQuery field's value. func (s InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeArgInQuery(v time.Time) InputService11TestShapeInputService11TestCaseOperation1Input { s.TimeArgInQuery = &v return s } // SetTimeCustom sets the TimeCustom field's value. func (s InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeCustom(v time.Time) InputService11TestShapeInputService11TestCaseOperation1Input { s.TimeCustom = &v return s } // SetTimeCustomInHeader sets the TimeCustomInHeader field's value. func (s InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeCustomInHeader(v time.Time) InputService11TestShapeInputService11TestCaseOperation1Input { s.TimeCustomInHeader = &v return s } // SetTimeCustomInQuery sets the TimeCustomInQuery field's value. func (s InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeCustomInQuery(v time.Time) InputService11TestShapeInputService11TestCaseOperation1Input { s.TimeCustomInQuery = &v return s } // SetTimeFormat sets the TimeFormat field's value. func (s InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeFormat(v time.Time) InputService11TestShapeInputService11TestCaseOperation1Input { s.TimeFormat = &v return s } // SetTimeFormatInHeader sets the TimeFormatInHeader field's value. func (s InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeFormatInHeader(v time.Time) InputService11TestShapeInputService11TestCaseOperation1Input { s.TimeFormatInHeader = &v return s } // SetTimeFormatInQuery sets the TimeFormatInQuery field's value. func (s InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeFormatInQuery(v time.Time) InputService11TestShapeInputService11TestCaseOperation1Input { s.TimeFormatInQuery = &v return s } type InputService11TestShapeInputService11TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // InputService12ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService12ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService12ProtocolTest struct { client.Client } // New creates a new instance of the InputService12ProtocolTest 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 InputService12ProtocolTest client from just a session. // svc := inputservice12protocoltest.New(mySession) // // // Create a InputService12ProtocolTest client with additional configuration // svc := inputservice12protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService12ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService12ProtocolTest { c := p.ClientConfig("inputservice12protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService12ProtocolTestClient(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 newInputService12ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService12ProtocolTest { svc := &InputService12ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService12ProtocolTest", ServiceID: "InputService12ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService12ProtocolTest operation and runs any // custom request initialization. func (c InputService12ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService12TestCaseOperation1 = "OperationName" // InputService12TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService12TestCaseOperation1 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 InputService12TestCaseOperation1 for more information on using the InputService12TestCaseOperation1 // 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 InputService12TestCaseOperation1Request method. // req, resp := client.InputService12TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService12ProtocolTest) InputService12TestCaseOperation1Request(input InputService12TestShapeInputService12TestCaseOperation1Input) (req request.Request, output InputService12TestShapeInputService12TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService12TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService12TestShapeInputService12TestCaseOperation1Input{} } output = &InputService12TestShapeInputService12TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService12TestCaseOperation1 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 InputService12TestCaseOperation1 for usage and error information. func (c InputService12ProtocolTest) InputService12TestCaseOperation1(input InputService12TestShapeInputService12TestCaseOperation1Input) (InputService12TestShapeInputService12TestCaseOperation1Output, error) { req, out := c.InputService12TestCaseOperation1Request(input) return out, req.Send() } // InputService12TestCaseOperation1WithContext is the same as InputService12TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService12TestCaseOperation1 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 InputService12ProtocolTest) InputService12TestCaseOperation1WithContext(ctx aws.Context, input InputService12TestShapeInputService12TestCaseOperation1Input, opts ...request.Option) (InputService12TestShapeInputService12TestCaseOperation1Output, error) { req, out := c.InputService12TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService12TestShapeInputService12TestCaseOperation1Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` Foo map[string]string `location:"headers" locationName:"x-foo-" type:"map"` } // SetFoo sets the Foo field's value. func (s InputService12TestShapeInputService12TestCaseOperation1Input) SetFoo(v map[string]string) InputService12TestShapeInputService12TestCaseOperation1Input { s.Foo = v return s } type InputService12TestShapeInputService12TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // InputService13ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService13ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService13ProtocolTest struct { client.Client } // New creates a new instance of the InputService13ProtocolTest 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 InputService13ProtocolTest client from just a session. // svc := inputservice13protocoltest.New(mySession) // // // Create a InputService13ProtocolTest client with additional configuration // svc := inputservice13protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService13ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService13ProtocolTest { c := p.ClientConfig("inputservice13protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService13ProtocolTestClient(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 newInputService13ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService13ProtocolTest { svc := &InputService13ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService13ProtocolTest", ServiceID: "InputService13ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService13ProtocolTest operation and runs any // custom request initialization. func (c InputService13ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService13TestCaseOperation1 = "OperationName" // InputService13TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService13TestCaseOperation1 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 InputService13TestCaseOperation1 for more information on using the InputService13TestCaseOperation1 // 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 InputService13TestCaseOperation1Request method. // req, resp := client.InputService13TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService13ProtocolTest) InputService13TestCaseOperation1Request(input InputService13TestShapeInputService13TestCaseOperation1Input) (req request.Request, output InputService13TestShapeInputService13TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService13TestCaseOperation1, HTTPMethod: "GET", HTTPPath: "/path", } if input == nil { input = &InputService13TestShapeInputService13TestCaseOperation1Input{} } output = &InputService13TestShapeInputService13TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService13TestCaseOperation1 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 InputService13TestCaseOperation1 for usage and error information. func (c InputService13ProtocolTest) InputService13TestCaseOperation1(input InputService13TestShapeInputService13TestCaseOperation1Input) (InputService13TestShapeInputService13TestCaseOperation1Output, error) { req, out := c.InputService13TestCaseOperation1Request(input) return out, req.Send() } // InputService13TestCaseOperation1WithContext is the same as InputService13TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService13TestCaseOperation1 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 InputService13ProtocolTest) InputService13TestCaseOperation1WithContext(ctx aws.Context, input InputService13TestShapeInputService13TestCaseOperation1Input, opts ...request.Option) (InputService13TestShapeInputService13TestCaseOperation1Output, error) { req, out := c.InputService13TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService13TestShapeInputService13TestCaseOperation1Input struct { _ struct{} `locationName:"InputShape" type:"structure"` Items []string `location:"querystring" locationName:"item" type:"list"` } // SetItems sets the Items field's value. func (s InputService13TestShapeInputService13TestCaseOperation1Input) SetItems(v []string) InputService13TestShapeInputService13TestCaseOperation1Input { s.Items = v return s } type InputService13TestShapeInputService13TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // InputService14ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService14ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService14ProtocolTest struct { client.Client } // New creates a new instance of the InputService14ProtocolTest 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 InputService14ProtocolTest client from just a session. // svc := inputservice14protocoltest.New(mySession) // // // Create a InputService14ProtocolTest client with additional configuration // svc := inputservice14protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService14ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService14ProtocolTest { c := p.ClientConfig("inputservice14protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService14ProtocolTestClient(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 newInputService14ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService14ProtocolTest { svc := &InputService14ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService14ProtocolTest", ServiceID: "InputService14ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService14ProtocolTest operation and runs any // custom request initialization. func (c InputService14ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService14TestCaseOperation1 = "OperationName" // InputService14TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService14TestCaseOperation1 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 InputService14TestCaseOperation1 for more information on using the InputService14TestCaseOperation1 // 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 InputService14TestCaseOperation1Request method. // req, resp := client.InputService14TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService14ProtocolTest) InputService14TestCaseOperation1Request(input InputService14TestShapeInputService14TestCaseOperation1Input) (req request.Request, output InputService14TestShapeInputService14TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService14TestCaseOperation1, HTTPMethod: "GET", HTTPPath: "/2014-01-01/jobsByPipeline/{PipelineId}", } if input == nil { input = &InputService14TestShapeInputService14TestCaseOperation1Input{} } output = &InputService14TestShapeInputService14TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService14TestCaseOperation1 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 InputService14TestCaseOperation1 for usage and error information. func (c InputService14ProtocolTest) InputService14TestCaseOperation1(input InputService14TestShapeInputService14TestCaseOperation1Input) (InputService14TestShapeInputService14TestCaseOperation1Output, error) { req, out := c.InputService14TestCaseOperation1Request(input) return out, req.Send() } // InputService14TestCaseOperation1WithContext is the same as InputService14TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService14TestCaseOperation1 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 InputService14ProtocolTest) InputService14TestCaseOperation1WithContext(ctx aws.Context, input InputService14TestShapeInputService14TestCaseOperation1Input, opts ...request.Option) (InputService14TestShapeInputService14TestCaseOperation1Output, error) { req, out := c.InputService14TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService14TestShapeInputService14TestCaseOperation1Input struct { _ struct{} `locationName:"InputShape" type:"structure"` // PipelineId is a required field PipelineId string `location:"uri" type:"string" required:"true"` QueryDoc map[string]string `location:"querystring" type:"map"` } // Validate inspects the fields of the type to determine if they are valid. func (s InputService14TestShapeInputService14TestCaseOperation1Input) Validate() error { invalidParams := request.ErrInvalidParams{Context: "InputService14TestShapeInputService14TestCaseOperation1Input"} if s.PipelineId == nil { invalidParams.Add(request.NewErrParamRequired("PipelineId")) } if s.PipelineId != nil && len(s.PipelineId) < 1 { invalidParams.Add(request.NewErrParamMinLen("PipelineId", 1)) } if invalidParams.Len() > 0 { return invalidParams } return nil } // SetPipelineId sets the PipelineId field's value. func (s InputService14TestShapeInputService14TestCaseOperation1Input) SetPipelineId(v string) InputService14TestShapeInputService14TestCaseOperation1Input { s.PipelineId = &v return s } // SetQueryDoc sets the QueryDoc field's value. func (s InputService14TestShapeInputService14TestCaseOperation1Input) SetQueryDoc(v map[string]string) InputService14TestShapeInputService14TestCaseOperation1Input { s.QueryDoc = v return s } type InputService14TestShapeInputService14TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // InputService15ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService15ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService15ProtocolTest struct { client.Client } // New creates a new instance of the InputService15ProtocolTest 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 InputService15ProtocolTest client from just a session. // svc := inputservice15protocoltest.New(mySession) // // // Create a InputService15ProtocolTest client with additional configuration // svc := inputservice15protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService15ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService15ProtocolTest { c := p.ClientConfig("inputservice15protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService15ProtocolTestClient(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 newInputService15ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService15ProtocolTest { svc := &InputService15ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService15ProtocolTest", ServiceID: "InputService15ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService15ProtocolTest operation and runs any // custom request initialization. func (c InputService15ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService15TestCaseOperation1 = "OperationName" // InputService15TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService15TestCaseOperation1 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 InputService15TestCaseOperation1 for more information on using the InputService15TestCaseOperation1 // 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 InputService15TestCaseOperation1Request method. // req, resp := client.InputService15TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService15ProtocolTest) InputService15TestCaseOperation1Request(input InputService15TestShapeInputService15TestCaseOperation1Input) (req request.Request, output InputService15TestShapeInputService15TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService15TestCaseOperation1, HTTPMethod: "GET", HTTPPath: "/2014-01-01/jobsByPipeline/{PipelineId}", } if input == nil { input = &InputService15TestShapeInputService15TestCaseOperation1Input{} } output = &InputService15TestShapeInputService15TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService15TestCaseOperation1 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 InputService15TestCaseOperation1 for usage and error information. func (c InputService15ProtocolTest) InputService15TestCaseOperation1(input InputService15TestShapeInputService15TestCaseOperation1Input) (InputService15TestShapeInputService15TestCaseOperation1Output, error) { req, out := c.InputService15TestCaseOperation1Request(input) return out, req.Send() } // InputService15TestCaseOperation1WithContext is the same as InputService15TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService15TestCaseOperation1 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 InputService15ProtocolTest) InputService15TestCaseOperation1WithContext(ctx aws.Context, input InputService15TestShapeInputService15TestCaseOperation1Input, opts ...request.Option) (InputService15TestShapeInputService15TestCaseOperation1Output, error) { req, out := c.InputService15TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService15TestShapeInputService15TestCaseOperation1Input struct { _ struct{} `locationName:"InputShape" type:"structure"` // PipelineId is a required field PipelineId string `location:"uri" type:"string" required:"true"` QueryDoc map[string][]string `location:"querystring" type:"map"` } // Validate inspects the fields of the type to determine if they are valid. func (s InputService15TestShapeInputService15TestCaseOperation1Input) Validate() error { invalidParams := request.ErrInvalidParams{Context: "InputService15TestShapeInputService15TestCaseOperation1Input"} if s.PipelineId == nil { invalidParams.Add(request.NewErrParamRequired("PipelineId")) } if s.PipelineId != nil && len(s.PipelineId) < 1 { invalidParams.Add(request.NewErrParamMinLen("PipelineId", 1)) } if invalidParams.Len() > 0 { return invalidParams } return nil } // SetPipelineId sets the PipelineId field's value. func (s InputService15TestShapeInputService15TestCaseOperation1Input) SetPipelineId(v string) InputService15TestShapeInputService15TestCaseOperation1Input { s.PipelineId = &v return s } // SetQueryDoc sets the QueryDoc field's value. func (s InputService15TestShapeInputService15TestCaseOperation1Input) SetQueryDoc(v map[string][]string) InputService15TestShapeInputService15TestCaseOperation1Input { s.QueryDoc = v return s } type InputService15TestShapeInputService15TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // InputService16ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService16ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService16ProtocolTest struct { client.Client } // New creates a new instance of the InputService16ProtocolTest 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 InputService16ProtocolTest client from just a session. // svc := inputservice16protocoltest.New(mySession) // // // Create a InputService16ProtocolTest client with additional configuration // svc := inputservice16protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService16ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService16ProtocolTest { c := p.ClientConfig("inputservice16protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService16ProtocolTestClient(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 newInputService16ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService16ProtocolTest { svc := &InputService16ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService16ProtocolTest", ServiceID: "InputService16ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService16ProtocolTest operation and runs any // custom request initialization. func (c InputService16ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService16TestCaseOperation1 = "OperationName" // InputService16TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService16TestCaseOperation1 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 InputService16TestCaseOperation1 for more information on using the InputService16TestCaseOperation1 // 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 InputService16TestCaseOperation1Request method. // req, resp := client.InputService16TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService16ProtocolTest) InputService16TestCaseOperation1Request(input InputService16TestShapeInputService16TestCaseOperation1Input) (req request.Request, output InputService16TestShapeInputService16TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService16TestCaseOperation1, HTTPMethod: "GET", HTTPPath: "/path", } if input == nil { input = &InputService16TestShapeInputService16TestCaseOperation1Input{} } output = &InputService16TestShapeInputService16TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService16TestCaseOperation1 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 InputService16TestCaseOperation1 for usage and error information. func (c InputService16ProtocolTest) InputService16TestCaseOperation1(input InputService16TestShapeInputService16TestCaseOperation1Input) (InputService16TestShapeInputService16TestCaseOperation1Output, error) { req, out := c.InputService16TestCaseOperation1Request(input) return out, req.Send() } // InputService16TestCaseOperation1WithContext is the same as InputService16TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService16TestCaseOperation1 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 InputService16ProtocolTest) InputService16TestCaseOperation1WithContext(ctx aws.Context, input InputService16TestShapeInputService16TestCaseOperation1Input, opts ...request.Option) (InputService16TestShapeInputService16TestCaseOperation1Output, error) { req, out := c.InputService16TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService16TestCaseOperation2 = "OperationName" // InputService16TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the InputService16TestCaseOperation2 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 InputService16TestCaseOperation2 for more information on using the InputService16TestCaseOperation2 // 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 InputService16TestCaseOperation2Request method. // req, resp := client.InputService16TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService16ProtocolTest) InputService16TestCaseOperation2Request(input InputService16TestShapeInputService16TestCaseOperation2Input) (req request.Request, output InputService16TestShapeInputService16TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService16TestCaseOperation2, HTTPMethod: "GET", HTTPPath: "/path", } if input == nil { input = &InputService16TestShapeInputService16TestCaseOperation2Input{} } output = &InputService16TestShapeInputService16TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService16TestCaseOperation2 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 InputService16TestCaseOperation2 for usage and error information. func (c InputService16ProtocolTest) InputService16TestCaseOperation2(input InputService16TestShapeInputService16TestCaseOperation2Input) (InputService16TestShapeInputService16TestCaseOperation2Output, error) { req, out := c.InputService16TestCaseOperation2Request(input) return out, req.Send() } // InputService16TestCaseOperation2WithContext is the same as InputService16TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See InputService16TestCaseOperation2 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 InputService16ProtocolTest) InputService16TestCaseOperation2WithContext(ctx aws.Context, input InputService16TestShapeInputService16TestCaseOperation2Input, opts ...request.Option) (InputService16TestShapeInputService16TestCaseOperation2Output, error) { req, out := c.InputService16TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService16TestShapeInputService16TestCaseOperation1Input struct { _ struct{} `locationName:"InputShape" type:"structure"` BoolQuery bool `location:"querystring" locationName:"bool-query" type:"boolean"` } // SetBoolQuery sets the BoolQuery field's value. func (s InputService16TestShapeInputService16TestCaseOperation1Input) SetBoolQuery(v bool) InputService16TestShapeInputService16TestCaseOperation1Input { s.BoolQuery = &v return s } type InputService16TestShapeInputService16TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService16TestShapeInputService16TestCaseOperation2Input struct { _ struct{} `locationName:"InputShape" type:"structure"` BoolQuery bool `location:"querystring" locationName:"bool-query" type:"boolean"` } // SetBoolQuery sets the BoolQuery field's value. func (s InputService16TestShapeInputService16TestCaseOperation2Input) SetBoolQuery(v bool) InputService16TestShapeInputService16TestCaseOperation2Input { s.BoolQuery = &v return s } type InputService16TestShapeInputService16TestCaseOperation2Output struct { _ struct{} `type:"structure"` } // InputService17ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService17ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService17ProtocolTest struct { client.Client } // New creates a new instance of the InputService17ProtocolTest 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 InputService17ProtocolTest client from just a session. // svc := inputservice17protocoltest.New(mySession) // // // Create a InputService17ProtocolTest client with additional configuration // svc := inputservice17protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService17ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService17ProtocolTest { c := p.ClientConfig("inputservice17protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService17ProtocolTestClient(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 newInputService17ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService17ProtocolTest { svc := &InputService17ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService17ProtocolTest", ServiceID: "InputService17ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService17ProtocolTest operation and runs any // custom request initialization. func (c InputService17ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService17TestCaseOperation1 = "OperationName" // InputService17TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService17TestCaseOperation1 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 InputService17TestCaseOperation1 for more information on using the InputService17TestCaseOperation1 // 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 InputService17TestCaseOperation1Request method. // req, resp := client.InputService17TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService17ProtocolTest) InputService17TestCaseOperation1Request(input InputService17TestShapeInputService17TestCaseOperation1Input) (req request.Request, output InputService17TestShapeInputService17TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService17TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService17TestShapeInputService17TestCaseOperation1Input{} } output = &InputService17TestShapeInputService17TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService17TestCaseOperation1 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 InputService17TestCaseOperation1 for usage and error information. func (c InputService17ProtocolTest) InputService17TestCaseOperation1(input InputService17TestShapeInputService17TestCaseOperation1Input) (InputService17TestShapeInputService17TestCaseOperation1Output, error) { req, out := c.InputService17TestCaseOperation1Request(input) return out, req.Send() } // InputService17TestCaseOperation1WithContext is the same as InputService17TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService17TestCaseOperation1 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 InputService17ProtocolTest) InputService17TestCaseOperation1WithContext(ctx aws.Context, input InputService17TestShapeInputService17TestCaseOperation1Input, opts ...request.Option) (InputService17TestShapeInputService17TestCaseOperation1Output, error) { req, out := c.InputService17TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService17TestShapeInputService17TestCaseOperation1Input struct { _ struct{} `locationName:"InputShape" type:"structure" payload:"Foo"` Foo string `locationName:"foo" type:"string"` } // SetFoo sets the Foo field's value. func (s InputService17TestShapeInputService17TestCaseOperation1Input) SetFoo(v string) InputService17TestShapeInputService17TestCaseOperation1Input { s.Foo = &v return s } type InputService17TestShapeInputService17TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // InputService18ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService18ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService18ProtocolTest struct { client.Client } // New creates a new instance of the InputService18ProtocolTest 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 InputService18ProtocolTest client from just a session. // svc := inputservice18protocoltest.New(mySession) // // // Create a InputService18ProtocolTest client with additional configuration // svc := inputservice18protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService18ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService18ProtocolTest { c := p.ClientConfig("inputservice18protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService18ProtocolTestClient(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 newInputService18ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService18ProtocolTest { svc := &InputService18ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService18ProtocolTest", ServiceID: "InputService18ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService18ProtocolTest operation and runs any // custom request initialization. func (c InputService18ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService18TestCaseOperation1 = "OperationName" // InputService18TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService18TestCaseOperation1 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 InputService18TestCaseOperation1 for more information on using the InputService18TestCaseOperation1 // 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 InputService18TestCaseOperation1Request method. // req, resp := client.InputService18TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService18ProtocolTest) InputService18TestCaseOperation1Request(input InputService18TestShapeInputService18TestCaseOperation1Input) (req request.Request, output InputService18TestShapeInputService18TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService18TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService18TestShapeInputService18TestCaseOperation1Input{} } output = &InputService18TestShapeInputService18TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService18TestCaseOperation1 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 InputService18TestCaseOperation1 for usage and error information. func (c InputService18ProtocolTest) InputService18TestCaseOperation1(input InputService18TestShapeInputService18TestCaseOperation1Input) (InputService18TestShapeInputService18TestCaseOperation1Output, error) { req, out := c.InputService18TestCaseOperation1Request(input) return out, req.Send() } // InputService18TestCaseOperation1WithContext is the same as InputService18TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService18TestCaseOperation1 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 InputService18ProtocolTest) InputService18TestCaseOperation1WithContext(ctx aws.Context, input InputService18TestShapeInputService18TestCaseOperation1Input, opts ...request.Option) (InputService18TestShapeInputService18TestCaseOperation1Output, error) { req, out := c.InputService18TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService18TestCaseOperation2 = "OperationName" // InputService18TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the InputService18TestCaseOperation2 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 InputService18TestCaseOperation2 for more information on using the InputService18TestCaseOperation2 // 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 InputService18TestCaseOperation2Request method. // req, resp := client.InputService18TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService18ProtocolTest) InputService18TestCaseOperation2Request(input InputService18TestShapeInputService18TestCaseOperation2Input) (req request.Request, output InputService18TestShapeInputService18TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService18TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService18TestShapeInputService18TestCaseOperation2Input{} } output = &InputService18TestShapeInputService18TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService18TestCaseOperation2 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 InputService18TestCaseOperation2 for usage and error information. func (c InputService18ProtocolTest) InputService18TestCaseOperation2(input InputService18TestShapeInputService18TestCaseOperation2Input) (InputService18TestShapeInputService18TestCaseOperation2Output, error) { req, out := c.InputService18TestCaseOperation2Request(input) return out, req.Send() } // InputService18TestCaseOperation2WithContext is the same as InputService18TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See InputService18TestCaseOperation2 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 InputService18ProtocolTest) InputService18TestCaseOperation2WithContext(ctx aws.Context, input InputService18TestShapeInputService18TestCaseOperation2Input, opts ...request.Option) (InputService18TestShapeInputService18TestCaseOperation2Output, error) { req, out := c.InputService18TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService18TestShapeInputService18TestCaseOperation1Input struct { _ struct{} `locationName:"InputShape" type:"structure" payload:"Foo"` Foo []byte `locationName:"foo" type:"blob"` } // SetFoo sets the Foo field's value. func (s InputService18TestShapeInputService18TestCaseOperation1Input) SetFoo(v []byte) InputService18TestShapeInputService18TestCaseOperation1Input { s.Foo = v return s } type InputService18TestShapeInputService18TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService18TestShapeInputService18TestCaseOperation2Input struct { _ struct{} `locationName:"InputShape" type:"structure" payload:"Foo"` Foo []byte `locationName:"foo" type:"blob"` } // SetFoo sets the Foo field's value. func (s InputService18TestShapeInputService18TestCaseOperation2Input) SetFoo(v []byte) InputService18TestShapeInputService18TestCaseOperation2Input { s.Foo = v return s } type InputService18TestShapeInputService18TestCaseOperation2Output struct { _ struct{} `type:"structure"` } // InputService19ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService19ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService19ProtocolTest struct { client.Client } // New creates a new instance of the InputService19ProtocolTest 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 InputService19ProtocolTest client from just a session. // svc := inputservice19protocoltest.New(mySession) // // // Create a InputService19ProtocolTest client with additional configuration // svc := inputservice19protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService19ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService19ProtocolTest { c := p.ClientConfig("inputservice19protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService19ProtocolTestClient(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 newInputService19ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService19ProtocolTest { svc := &InputService19ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService19ProtocolTest", ServiceID: "InputService19ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService19ProtocolTest operation and runs any // custom request initialization. func (c InputService19ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService19TestCaseOperation1 = "OperationName" // InputService19TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService19TestCaseOperation1 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 InputService19TestCaseOperation1 for more information on using the InputService19TestCaseOperation1 // 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 InputService19TestCaseOperation1Request method. // req, resp := client.InputService19TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService19ProtocolTest) InputService19TestCaseOperation1Request(input InputService19TestShapeInputService19TestCaseOperation1Input) (req request.Request, output InputService19TestShapeInputService19TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService19TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService19TestShapeInputService19TestCaseOperation1Input{} } output = &InputService19TestShapeInputService19TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService19TestCaseOperation1 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 InputService19TestCaseOperation1 for usage and error information. func (c InputService19ProtocolTest) InputService19TestCaseOperation1(input InputService19TestShapeInputService19TestCaseOperation1Input) (InputService19TestShapeInputService19TestCaseOperation1Output, error) { req, out := c.InputService19TestCaseOperation1Request(input) return out, req.Send() } // InputService19TestCaseOperation1WithContext is the same as InputService19TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService19TestCaseOperation1 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 InputService19ProtocolTest) InputService19TestCaseOperation1WithContext(ctx aws.Context, input InputService19TestShapeInputService19TestCaseOperation1Input, opts ...request.Option) (InputService19TestShapeInputService19TestCaseOperation1Output, error) { req, out := c.InputService19TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService19TestCaseOperation2 = "OperationName" // InputService19TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the InputService19TestCaseOperation2 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 InputService19TestCaseOperation2 for more information on using the InputService19TestCaseOperation2 // 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 InputService19TestCaseOperation2Request method. // req, resp := client.InputService19TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService19ProtocolTest) InputService19TestCaseOperation2Request(input InputService19TestShapeInputService19TestCaseOperation2Input) (req request.Request, output InputService19TestShapeInputService19TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService19TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService19TestShapeInputService19TestCaseOperation2Input{} } output = &InputService19TestShapeInputService19TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService19TestCaseOperation2 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 InputService19TestCaseOperation2 for usage and error information. func (c InputService19ProtocolTest) InputService19TestCaseOperation2(input InputService19TestShapeInputService19TestCaseOperation2Input) (InputService19TestShapeInputService19TestCaseOperation2Output, error) { req, out := c.InputService19TestCaseOperation2Request(input) return out, req.Send() } // InputService19TestCaseOperation2WithContext is the same as InputService19TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See InputService19TestCaseOperation2 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 InputService19ProtocolTest) InputService19TestCaseOperation2WithContext(ctx aws.Context, input InputService19TestShapeInputService19TestCaseOperation2Input, opts ...request.Option) (InputService19TestShapeInputService19TestCaseOperation2Output, error) { req, out := c.InputService19TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService19TestCaseOperation3 = "OperationName" // InputService19TestCaseOperation3Request generates a "aws/request.Request" representing the // client's request for the InputService19TestCaseOperation3 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 InputService19TestCaseOperation3 for more information on using the InputService19TestCaseOperation3 // 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 InputService19TestCaseOperation3Request method. // req, resp := client.InputService19TestCaseOperation3Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService19ProtocolTest) InputService19TestCaseOperation3Request(input InputService19TestShapeInputService19TestCaseOperation3Input) (req request.Request, output InputService19TestShapeInputService19TestCaseOperation3Output) { op := &request.Operation{ Name: opInputService19TestCaseOperation3, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService19TestShapeInputService19TestCaseOperation3Input{} } output = &InputService19TestShapeInputService19TestCaseOperation3Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService19TestCaseOperation3 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 InputService19TestCaseOperation3 for usage and error information. func (c InputService19ProtocolTest) InputService19TestCaseOperation3(input InputService19TestShapeInputService19TestCaseOperation3Input) (InputService19TestShapeInputService19TestCaseOperation3Output, error) { req, out := c.InputService19TestCaseOperation3Request(input) return out, req.Send() } // InputService19TestCaseOperation3WithContext is the same as InputService19TestCaseOperation3 with the addition of // the ability to pass a context and additional request options. // // See InputService19TestCaseOperation3 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 InputService19ProtocolTest) InputService19TestCaseOperation3WithContext(ctx aws.Context, input InputService19TestShapeInputService19TestCaseOperation3Input, opts ...request.Option) (InputService19TestShapeInputService19TestCaseOperation3Output, error) { req, out := c.InputService19TestCaseOperation3Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService19TestCaseOperation4 = "OperationName" // InputService19TestCaseOperation4Request generates a "aws/request.Request" representing the // client's request for the InputService19TestCaseOperation4 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 InputService19TestCaseOperation4 for more information on using the InputService19TestCaseOperation4 // 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 InputService19TestCaseOperation4Request method. // req, resp := client.InputService19TestCaseOperation4Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService19ProtocolTest) InputService19TestCaseOperation4Request(input InputService19TestShapeInputService19TestCaseOperation4Input) (req request.Request, output InputService19TestShapeInputService19TestCaseOperation4Output) { op := &request.Operation{ Name: opInputService19TestCaseOperation4, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService19TestShapeInputService19TestCaseOperation4Input{} } output = &InputService19TestShapeInputService19TestCaseOperation4Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService19TestCaseOperation4 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 InputService19TestCaseOperation4 for usage and error information. func (c InputService19ProtocolTest) InputService19TestCaseOperation4(input InputService19TestShapeInputService19TestCaseOperation4Input) (InputService19TestShapeInputService19TestCaseOperation4Output, error) { req, out := c.InputService19TestCaseOperation4Request(input) return out, req.Send() } // InputService19TestCaseOperation4WithContext is the same as InputService19TestCaseOperation4 with the addition of // the ability to pass a context and additional request options. // // See InputService19TestCaseOperation4 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 InputService19ProtocolTest) InputService19TestCaseOperation4WithContext(ctx aws.Context, input InputService19TestShapeInputService19TestCaseOperation4Input, opts ...request.Option) (InputService19TestShapeInputService19TestCaseOperation4Output, error) { req, out := c.InputService19TestCaseOperation4Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService19TestShapeFooShape struct { _ struct{} `locationName:"foo" type:"structure"` Baz string `locationName:"baz" type:"string"` } // SetBaz sets the Baz field's value. func (s InputService19TestShapeFooShape) SetBaz(v string) InputService19TestShapeFooShape { s.Baz = &v return s } type InputService19TestShapeInputService19TestCaseOperation1Input struct { _ struct{} `locationName:"InputShape" type:"structure" payload:"Foo"` Foo InputService19TestShapeFooShape `locationName:"foo" type:"structure"` } // SetFoo sets the Foo field's value. func (s InputService19TestShapeInputService19TestCaseOperation1Input) SetFoo(v InputService19TestShapeFooShape) InputService19TestShapeInputService19TestCaseOperation1Input { s.Foo = v return s } type InputService19TestShapeInputService19TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService19TestShapeInputService19TestCaseOperation2Input struct { _ struct{} `locationName:"InputShape" type:"structure" payload:"Foo"` Foo InputService19TestShapeFooShape `locationName:"foo" type:"structure"` } // SetFoo sets the Foo field's value. func (s InputService19TestShapeInputService19TestCaseOperation2Input) SetFoo(v InputService19TestShapeFooShape) InputService19TestShapeInputService19TestCaseOperation2Input { s.Foo = v return s } type InputService19TestShapeInputService19TestCaseOperation2Output struct { _ struct{} `type:"structure"` } type InputService19TestShapeInputService19TestCaseOperation3Input struct { _ struct{} `locationName:"InputShape" type:"structure" payload:"Foo"` Foo InputService19TestShapeFooShape `locationName:"foo" type:"structure"` } // SetFoo sets the Foo field's value. func (s InputService19TestShapeInputService19TestCaseOperation3Input) SetFoo(v InputService19TestShapeFooShape) InputService19TestShapeInputService19TestCaseOperation3Input { s.Foo = v return s } type InputService19TestShapeInputService19TestCaseOperation3Output struct { _ struct{} `type:"structure"` } type InputService19TestShapeInputService19TestCaseOperation4Input struct { _ struct{} `locationName:"InputShape" type:"structure" payload:"Foo"` Foo InputService19TestShapeFooShape `locationName:"foo" type:"structure"` } // SetFoo sets the Foo field's value. func (s InputService19TestShapeInputService19TestCaseOperation4Input) SetFoo(v InputService19TestShapeFooShape) InputService19TestShapeInputService19TestCaseOperation4Input { s.Foo = v return s } type InputService19TestShapeInputService19TestCaseOperation4Output struct { _ struct{} `type:"structure"` } // InputService20ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService20ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService20ProtocolTest struct { client.Client } // New creates a new instance of the InputService20ProtocolTest 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 InputService20ProtocolTest client from just a session. // svc := inputservice20protocoltest.New(mySession) // // // Create a InputService20ProtocolTest client with additional configuration // svc := inputservice20protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService20ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService20ProtocolTest { c := p.ClientConfig("inputservice20protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService20ProtocolTestClient(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 newInputService20ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService20ProtocolTest { svc := &InputService20ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService20ProtocolTest", ServiceID: "InputService20ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService20ProtocolTest operation and runs any // custom request initialization. func (c InputService20ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService20TestCaseOperation1 = "OperationName" // InputService20TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService20TestCaseOperation1 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 InputService20TestCaseOperation1 for more information on using the InputService20TestCaseOperation1 // 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 InputService20TestCaseOperation1Request method. // req, resp := client.InputService20TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService20ProtocolTest) InputService20TestCaseOperation1Request(input InputService20TestShapeInputService20TestCaseOperation1Input) (req request.Request, output InputService20TestShapeInputService20TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService20TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/", } if input == nil { input = &InputService20TestShapeInputService20TestCaseOperation1Input{} } output = &InputService20TestShapeInputService20TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService20TestCaseOperation1 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 InputService20TestCaseOperation1 for usage and error information. func (c InputService20ProtocolTest) InputService20TestCaseOperation1(input InputService20TestShapeInputService20TestCaseOperation1Input) (InputService20TestShapeInputService20TestCaseOperation1Output, error) { req, out := c.InputService20TestCaseOperation1Request(input) return out, req.Send() } // InputService20TestCaseOperation1WithContext is the same as InputService20TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService20TestCaseOperation1 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 InputService20ProtocolTest) InputService20TestCaseOperation1WithContext(ctx aws.Context, input InputService20TestShapeInputService20TestCaseOperation1Input, opts ...request.Option) (InputService20TestShapeInputService20TestCaseOperation1Output, error) { req, out := c.InputService20TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService20TestShapeGrant struct { _ struct{} `locationName:"Grant" type:"structure"` Grantee InputService20TestShapeGrantee `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"` } // SetGrantee sets the Grantee field's value. func (s InputService20TestShapeGrant) SetGrantee(v InputService20TestShapeGrantee) InputService20TestShapeGrant { s.Grantee = v return s } type InputService20TestShapeGrantee struct { _ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"` EmailAddress string `type:"string"` Type string `locationName:"xsi:type" type:"string" xmlAttribute:"true"` } // SetEmailAddress sets the EmailAddress field's value. func (s InputService20TestShapeGrantee) SetEmailAddress(v string) InputService20TestShapeGrantee { s.EmailAddress = &v return s } // SetType sets the Type field's value. func (s InputService20TestShapeGrantee) SetType(v string) InputService20TestShapeGrantee { s.Type = &v return s } type InputService20TestShapeInputService20TestCaseOperation1Input struct { _ struct{} `locationName:"InputShape" type:"structure" payload:"Grant"` Grant InputService20TestShapeGrant `locationName:"Grant" type:"structure"` } // SetGrant sets the Grant field's value. func (s InputService20TestShapeInputService20TestCaseOperation1Input) SetGrant(v InputService20TestShapeGrant) InputService20TestShapeInputService20TestCaseOperation1Input { s.Grant = v return s } type InputService20TestShapeInputService20TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // InputService21ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService21ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService21ProtocolTest struct { client.Client } // New creates a new instance of the InputService21ProtocolTest 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 InputService21ProtocolTest client from just a session. // svc := inputservice21protocoltest.New(mySession) // // // Create a InputService21ProtocolTest client with additional configuration // svc := inputservice21protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService21ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService21ProtocolTest { c := p.ClientConfig("inputservice21protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService21ProtocolTestClient(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 newInputService21ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService21ProtocolTest { svc := &InputService21ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService21ProtocolTest", ServiceID: "InputService21ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService21ProtocolTest operation and runs any // custom request initialization. func (c InputService21ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService21TestCaseOperation1 = "OperationName" // InputService21TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService21TestCaseOperation1 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 InputService21TestCaseOperation1 for more information on using the InputService21TestCaseOperation1 // 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 InputService21TestCaseOperation1Request method. // req, resp := client.InputService21TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService21ProtocolTest) InputService21TestCaseOperation1Request(input InputService21TestShapeInputService21TestCaseOperation1Input) (req request.Request, output InputService21TestShapeInputService21TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService21TestCaseOperation1, HTTPMethod: "GET", HTTPPath: "/{Bucket}/{Key+}", } if input == nil { input = &InputService21TestShapeInputService21TestCaseOperation1Input{} } output = &InputService21TestShapeInputService21TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService21TestCaseOperation1 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 InputService21TestCaseOperation1 for usage and error information. func (c InputService21ProtocolTest) InputService21TestCaseOperation1(input InputService21TestShapeInputService21TestCaseOperation1Input) (InputService21TestShapeInputService21TestCaseOperation1Output, error) { req, out := c.InputService21TestCaseOperation1Request(input) return out, req.Send() } // InputService21TestCaseOperation1WithContext is the same as InputService21TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService21TestCaseOperation1 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 InputService21ProtocolTest) InputService21TestCaseOperation1WithContext(ctx aws.Context, input InputService21TestShapeInputService21TestCaseOperation1Input, opts ...request.Option) (InputService21TestShapeInputService21TestCaseOperation1Output, error) { req, out := c.InputService21TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService21TestShapeInputService21TestCaseOperation1Input struct { _ struct{} `locationName:"InputShape" type:"structure"` // Bucket is a required field Bucket string `location:"uri" type:"string" required:"true"` // Key is a required field Key string `location:"uri" type:"string" required:"true"` } // Validate inspects the fields of the type to determine if they are valid. func (s InputService21TestShapeInputService21TestCaseOperation1Input) Validate() error { invalidParams := request.ErrInvalidParams{Context: "InputService21TestShapeInputService21TestCaseOperation1Input"} if s.Bucket == nil { invalidParams.Add(request.NewErrParamRequired("Bucket")) } if s.Bucket != nil && len(s.Bucket) < 1 { invalidParams.Add(request.NewErrParamMinLen("Bucket", 1)) } if s.Key == nil { invalidParams.Add(request.NewErrParamRequired("Key")) } if s.Key != nil && len(s.Key) < 1 { invalidParams.Add(request.NewErrParamMinLen("Key", 1)) } if invalidParams.Len() > 0 { return invalidParams } return nil } // SetBucket sets the Bucket field's value. func (s InputService21TestShapeInputService21TestCaseOperation1Input) SetBucket(v string) InputService21TestShapeInputService21TestCaseOperation1Input { s.Bucket = &v return s } // SetKey sets the Key field's value. func (s InputService21TestShapeInputService21TestCaseOperation1Input) SetKey(v string) InputService21TestShapeInputService21TestCaseOperation1Input { s.Key = &v return s } type InputService21TestShapeInputService21TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // InputService22ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService22ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService22ProtocolTest struct { client.Client } // New creates a new instance of the InputService22ProtocolTest 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 InputService22ProtocolTest client from just a session. // svc := inputservice22protocoltest.New(mySession) // // // Create a InputService22ProtocolTest client with additional configuration // svc := inputservice22protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService22ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService22ProtocolTest { c := p.ClientConfig("inputservice22protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService22ProtocolTestClient(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 newInputService22ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService22ProtocolTest { svc := &InputService22ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService22ProtocolTest", ServiceID: "InputService22ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService22ProtocolTest operation and runs any // custom request initialization. func (c InputService22ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService22TestCaseOperation1 = "OperationName" // InputService22TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService22TestCaseOperation1 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 InputService22TestCaseOperation1 for more information on using the InputService22TestCaseOperation1 // 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 InputService22TestCaseOperation1Request method. // req, resp := client.InputService22TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService22ProtocolTest) InputService22TestCaseOperation1Request(input InputService22TestShapeInputService22TestCaseOperation1Input) (req request.Request, output InputService22TestShapeInputService22TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService22TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService22TestShapeInputService22TestCaseOperation1Input{} } output = &InputService22TestShapeInputService22TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService22TestCaseOperation1 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 InputService22TestCaseOperation1 for usage and error information. func (c InputService22ProtocolTest) InputService22TestCaseOperation1(input InputService22TestShapeInputService22TestCaseOperation1Input) (InputService22TestShapeInputService22TestCaseOperation1Output, error) { req, out := c.InputService22TestCaseOperation1Request(input) return out, req.Send() } // InputService22TestCaseOperation1WithContext is the same as InputService22TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService22TestCaseOperation1 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 InputService22ProtocolTest) InputService22TestCaseOperation1WithContext(ctx aws.Context, input InputService22TestShapeInputService22TestCaseOperation1Input, opts ...request.Option) (InputService22TestShapeInputService22TestCaseOperation1Output, error) { req, out := c.InputService22TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService22TestCaseOperation2 = "OperationName" // InputService22TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the InputService22TestCaseOperation2 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 InputService22TestCaseOperation2 for more information on using the InputService22TestCaseOperation2 // 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 InputService22TestCaseOperation2Request method. // req, resp := client.InputService22TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService22ProtocolTest) InputService22TestCaseOperation2Request(input InputService22TestShapeInputService22TestCaseOperation2Input) (req request.Request, output InputService22TestShapeInputService22TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService22TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/path?abc=mno", } if input == nil { input = &InputService22TestShapeInputService22TestCaseOperation2Input{} } output = &InputService22TestShapeInputService22TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService22TestCaseOperation2 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 InputService22TestCaseOperation2 for usage and error information. func (c InputService22ProtocolTest) InputService22TestCaseOperation2(input InputService22TestShapeInputService22TestCaseOperation2Input) (InputService22TestShapeInputService22TestCaseOperation2Output, error) { req, out := c.InputService22TestCaseOperation2Request(input) return out, req.Send() } // InputService22TestCaseOperation2WithContext is the same as InputService22TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See InputService22TestCaseOperation2 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 InputService22ProtocolTest) InputService22TestCaseOperation2WithContext(ctx aws.Context, input InputService22TestShapeInputService22TestCaseOperation2Input, opts ...request.Option) (InputService22TestShapeInputService22TestCaseOperation2Output, error) { req, out := c.InputService22TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService22TestShapeInputService22TestCaseOperation1Input struct { _ struct{} `locationName:"InputShape" type:"structure"` Foo string `location:"querystring" locationName:"param-name" type:"string"` } // SetFoo sets the Foo field's value. func (s InputService22TestShapeInputService22TestCaseOperation1Input) SetFoo(v string) InputService22TestShapeInputService22TestCaseOperation1Input { s.Foo = &v return s } type InputService22TestShapeInputService22TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService22TestShapeInputService22TestCaseOperation2Input struct { _ struct{} `locationName:"InputShape" type:"structure"` Foo string `location:"querystring" locationName:"param-name" type:"string"` } // SetFoo sets the Foo field's value. func (s InputService22TestShapeInputService22TestCaseOperation2Input) SetFoo(v string) InputService22TestShapeInputService22TestCaseOperation2Input { s.Foo = &v return s } type InputService22TestShapeInputService22TestCaseOperation2Output struct { _ struct{} `type:"structure"` } // InputService23ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService23ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService23ProtocolTest struct { client.Client } // New creates a new instance of the InputService23ProtocolTest 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 InputService23ProtocolTest client from just a session. // svc := inputservice23protocoltest.New(mySession) // // // Create a InputService23ProtocolTest client with additional configuration // svc := inputservice23protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService23ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService23ProtocolTest { c := p.ClientConfig("inputservice23protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService23ProtocolTestClient(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 newInputService23ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService23ProtocolTest { svc := &InputService23ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService23ProtocolTest", ServiceID: "InputService23ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService23ProtocolTest operation and runs any // custom request initialization. func (c InputService23ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService23TestCaseOperation1 = "OperationName" // InputService23TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService23TestCaseOperation1 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 InputService23TestCaseOperation1 for more information on using the InputService23TestCaseOperation1 // 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 InputService23TestCaseOperation1Request method. // req, resp := client.InputService23TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService23ProtocolTest) InputService23TestCaseOperation1Request(input InputService23TestShapeInputService23TestCaseOperation1Input) (req request.Request, output InputService23TestShapeInputService23TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService23TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService23TestShapeInputService23TestCaseOperation1Input{} } output = &InputService23TestShapeInputService23TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService23TestCaseOperation1 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 InputService23TestCaseOperation1 for usage and error information. func (c InputService23ProtocolTest) InputService23TestCaseOperation1(input InputService23TestShapeInputService23TestCaseOperation1Input) (InputService23TestShapeInputService23TestCaseOperation1Output, error) { req, out := c.InputService23TestCaseOperation1Request(input) return out, req.Send() } // InputService23TestCaseOperation1WithContext is the same as InputService23TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService23TestCaseOperation1 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 InputService23ProtocolTest) InputService23TestCaseOperation1WithContext(ctx aws.Context, input InputService23TestShapeInputService23TestCaseOperation1Input, opts ...request.Option) (InputService23TestShapeInputService23TestCaseOperation1Output, error) { req, out := c.InputService23TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService23TestCaseOperation2 = "OperationName" // InputService23TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the InputService23TestCaseOperation2 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 InputService23TestCaseOperation2 for more information on using the InputService23TestCaseOperation2 // 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 InputService23TestCaseOperation2Request method. // req, resp := client.InputService23TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService23ProtocolTest) InputService23TestCaseOperation2Request(input InputService23TestShapeInputService23TestCaseOperation2Input) (req request.Request, output InputService23TestShapeInputService23TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService23TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService23TestShapeInputService23TestCaseOperation2Input{} } output = &InputService23TestShapeInputService23TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService23TestCaseOperation2 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 InputService23TestCaseOperation2 for usage and error information. func (c InputService23ProtocolTest) InputService23TestCaseOperation2(input InputService23TestShapeInputService23TestCaseOperation2Input) (InputService23TestShapeInputService23TestCaseOperation2Output, error) { req, out := c.InputService23TestCaseOperation2Request(input) return out, req.Send() } // InputService23TestCaseOperation2WithContext is the same as InputService23TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See InputService23TestCaseOperation2 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 InputService23ProtocolTest) InputService23TestCaseOperation2WithContext(ctx aws.Context, input InputService23TestShapeInputService23TestCaseOperation2Input, opts ...request.Option) (InputService23TestShapeInputService23TestCaseOperation2Output, error) { req, out := c.InputService23TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService23TestCaseOperation3 = "OperationName" // InputService23TestCaseOperation3Request generates a "aws/request.Request" representing the // client's request for the InputService23TestCaseOperation3 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 InputService23TestCaseOperation3 for more information on using the InputService23TestCaseOperation3 // 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 InputService23TestCaseOperation3Request method. // req, resp := client.InputService23TestCaseOperation3Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService23ProtocolTest) InputService23TestCaseOperation3Request(input InputService23TestShapeInputService23TestCaseOperation3Input) (req request.Request, output InputService23TestShapeInputService23TestCaseOperation3Output) { op := &request.Operation{ Name: opInputService23TestCaseOperation3, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService23TestShapeInputService23TestCaseOperation3Input{} } output = &InputService23TestShapeInputService23TestCaseOperation3Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService23TestCaseOperation3 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 InputService23TestCaseOperation3 for usage and error information. func (c InputService23ProtocolTest) InputService23TestCaseOperation3(input InputService23TestShapeInputService23TestCaseOperation3Input) (InputService23TestShapeInputService23TestCaseOperation3Output, error) { req, out := c.InputService23TestCaseOperation3Request(input) return out, req.Send() } // InputService23TestCaseOperation3WithContext is the same as InputService23TestCaseOperation3 with the addition of // the ability to pass a context and additional request options. // // See InputService23TestCaseOperation3 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 InputService23ProtocolTest) InputService23TestCaseOperation3WithContext(ctx aws.Context, input InputService23TestShapeInputService23TestCaseOperation3Input, opts ...request.Option) (InputService23TestShapeInputService23TestCaseOperation3Output, error) { req, out := c.InputService23TestCaseOperation3Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService23TestCaseOperation4 = "OperationName" // InputService23TestCaseOperation4Request generates a "aws/request.Request" representing the // client's request for the InputService23TestCaseOperation4 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 InputService23TestCaseOperation4 for more information on using the InputService23TestCaseOperation4 // 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 InputService23TestCaseOperation4Request method. // req, resp := client.InputService23TestCaseOperation4Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService23ProtocolTest) InputService23TestCaseOperation4Request(input InputService23TestShapeInputService23TestCaseOperation4Input) (req request.Request, output InputService23TestShapeInputService23TestCaseOperation4Output) { op := &request.Operation{ Name: opInputService23TestCaseOperation4, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService23TestShapeInputService23TestCaseOperation4Input{} } output = &InputService23TestShapeInputService23TestCaseOperation4Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService23TestCaseOperation4 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 InputService23TestCaseOperation4 for usage and error information. func (c InputService23ProtocolTest) InputService23TestCaseOperation4(input InputService23TestShapeInputService23TestCaseOperation4Input) (InputService23TestShapeInputService23TestCaseOperation4Output, error) { req, out := c.InputService23TestCaseOperation4Request(input) return out, req.Send() } // InputService23TestCaseOperation4WithContext is the same as InputService23TestCaseOperation4 with the addition of // the ability to pass a context and additional request options. // // See InputService23TestCaseOperation4 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 InputService23ProtocolTest) InputService23TestCaseOperation4WithContext(ctx aws.Context, input InputService23TestShapeInputService23TestCaseOperation4Input, opts ...request.Option) (InputService23TestShapeInputService23TestCaseOperation4Output, error) { req, out := c.InputService23TestCaseOperation4Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService23TestCaseOperation5 = "OperationName" // InputService23TestCaseOperation5Request generates a "aws/request.Request" representing the // client's request for the InputService23TestCaseOperation5 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 InputService23TestCaseOperation5 for more information on using the InputService23TestCaseOperation5 // 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 InputService23TestCaseOperation5Request method. // req, resp := client.InputService23TestCaseOperation5Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService23ProtocolTest) InputService23TestCaseOperation5Request(input InputService23TestShapeInputService23TestCaseOperation5Input) (req request.Request, output InputService23TestShapeInputService23TestCaseOperation5Output) { op := &request.Operation{ Name: opInputService23TestCaseOperation5, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService23TestShapeInputService23TestCaseOperation5Input{} } output = &InputService23TestShapeInputService23TestCaseOperation5Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService23TestCaseOperation5 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 InputService23TestCaseOperation5 for usage and error information. func (c InputService23ProtocolTest) InputService23TestCaseOperation5(input InputService23TestShapeInputService23TestCaseOperation5Input) (InputService23TestShapeInputService23TestCaseOperation5Output, error) { req, out := c.InputService23TestCaseOperation5Request(input) return out, req.Send() } // InputService23TestCaseOperation5WithContext is the same as InputService23TestCaseOperation5 with the addition of // the ability to pass a context and additional request options. // // See InputService23TestCaseOperation5 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 InputService23ProtocolTest) InputService23TestCaseOperation5WithContext(ctx aws.Context, input InputService23TestShapeInputService23TestCaseOperation5Input, opts ...request.Option) (InputService23TestShapeInputService23TestCaseOperation5Output, error) { req, out := c.InputService23TestCaseOperation5Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService23TestCaseOperation6 = "OperationName" // InputService23TestCaseOperation6Request generates a "aws/request.Request" representing the // client's request for the InputService23TestCaseOperation6 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 InputService23TestCaseOperation6 for more information on using the InputService23TestCaseOperation6 // 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 InputService23TestCaseOperation6Request method. // req, resp := client.InputService23TestCaseOperation6Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService23ProtocolTest) InputService23TestCaseOperation6Request(input InputService23TestShapeInputService23TestCaseOperation6Input) (req request.Request, output InputService23TestShapeInputService23TestCaseOperation6Output) { op := &request.Operation{ Name: opInputService23TestCaseOperation6, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService23TestShapeInputService23TestCaseOperation6Input{} } output = &InputService23TestShapeInputService23TestCaseOperation6Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService23TestCaseOperation6 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 InputService23TestCaseOperation6 for usage and error information. func (c InputService23ProtocolTest) InputService23TestCaseOperation6(input InputService23TestShapeInputService23TestCaseOperation6Input) (InputService23TestShapeInputService23TestCaseOperation6Output, error) { req, out := c.InputService23TestCaseOperation6Request(input) return out, req.Send() } // InputService23TestCaseOperation6WithContext is the same as InputService23TestCaseOperation6 with the addition of // the ability to pass a context and additional request options. // // See InputService23TestCaseOperation6 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 InputService23ProtocolTest) InputService23TestCaseOperation6WithContext(ctx aws.Context, input InputService23TestShapeInputService23TestCaseOperation6Input, opts ...request.Option) (InputService23TestShapeInputService23TestCaseOperation6Output, error) { req, out := c.InputService23TestCaseOperation6Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService23TestShapeInputService23TestCaseOperation1Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` RecursiveStruct InputService23TestShapeRecursiveStructType `type:"structure"` } // SetRecursiveStruct sets the RecursiveStruct field's value. func (s InputService23TestShapeInputService23TestCaseOperation1Input) SetRecursiveStruct(v InputService23TestShapeRecursiveStructType) InputService23TestShapeInputService23TestCaseOperation1Input { s.RecursiveStruct = v return s } type InputService23TestShapeInputService23TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService23TestShapeInputService23TestCaseOperation2Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` RecursiveStruct InputService23TestShapeRecursiveStructType `type:"structure"` } // SetRecursiveStruct sets the RecursiveStruct field's value. func (s InputService23TestShapeInputService23TestCaseOperation2Input) SetRecursiveStruct(v InputService23TestShapeRecursiveStructType) InputService23TestShapeInputService23TestCaseOperation2Input { s.RecursiveStruct = v return s } type InputService23TestShapeInputService23TestCaseOperation2Output struct { _ struct{} `type:"structure"` } type InputService23TestShapeInputService23TestCaseOperation3Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` RecursiveStruct InputService23TestShapeRecursiveStructType `type:"structure"` } // SetRecursiveStruct sets the RecursiveStruct field's value. func (s InputService23TestShapeInputService23TestCaseOperation3Input) SetRecursiveStruct(v InputService23TestShapeRecursiveStructType) InputService23TestShapeInputService23TestCaseOperation3Input { s.RecursiveStruct = v return s } type InputService23TestShapeInputService23TestCaseOperation3Output struct { _ struct{} `type:"structure"` } type InputService23TestShapeInputService23TestCaseOperation4Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` RecursiveStruct InputService23TestShapeRecursiveStructType `type:"structure"` } // SetRecursiveStruct sets the RecursiveStruct field's value. func (s InputService23TestShapeInputService23TestCaseOperation4Input) SetRecursiveStruct(v InputService23TestShapeRecursiveStructType) InputService23TestShapeInputService23TestCaseOperation4Input { s.RecursiveStruct = v return s } type InputService23TestShapeInputService23TestCaseOperation4Output struct { _ struct{} `type:"structure"` } type InputService23TestShapeInputService23TestCaseOperation5Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` RecursiveStruct InputService23TestShapeRecursiveStructType `type:"structure"` } // SetRecursiveStruct sets the RecursiveStruct field's value. func (s InputService23TestShapeInputService23TestCaseOperation5Input) SetRecursiveStruct(v InputService23TestShapeRecursiveStructType) InputService23TestShapeInputService23TestCaseOperation5Input { s.RecursiveStruct = v return s } type InputService23TestShapeInputService23TestCaseOperation5Output struct { _ struct{} `type:"structure"` } type InputService23TestShapeInputService23TestCaseOperation6Input struct { _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` RecursiveStruct InputService23TestShapeRecursiveStructType `type:"structure"` } // SetRecursiveStruct sets the RecursiveStruct field's value. func (s InputService23TestShapeInputService23TestCaseOperation6Input) SetRecursiveStruct(v InputService23TestShapeRecursiveStructType) InputService23TestShapeInputService23TestCaseOperation6Input { s.RecursiveStruct = v return s } type InputService23TestShapeInputService23TestCaseOperation6Output struct { _ struct{} `type:"structure"` } type InputService23TestShapeRecursiveStructType struct { _ struct{} `type:"structure"` NoRecurse string `type:"string"` RecursiveList []InputService23TestShapeRecursiveStructType `type:"list"` RecursiveMap map[string]InputService23TestShapeRecursiveStructType `type:"map"` RecursiveStruct InputService23TestShapeRecursiveStructType `type:"structure"` } // SetNoRecurse sets the NoRecurse field's value. func (s InputService23TestShapeRecursiveStructType) SetNoRecurse(v string) InputService23TestShapeRecursiveStructType { s.NoRecurse = &v return s } // SetRecursiveList sets the RecursiveList field's value. func (s InputService23TestShapeRecursiveStructType) SetRecursiveList(v []InputService23TestShapeRecursiveStructType) InputService23TestShapeRecursiveStructType { s.RecursiveList = v return s } // SetRecursiveMap sets the RecursiveMap field's value. func (s InputService23TestShapeRecursiveStructType) SetRecursiveMap(v map[string]InputService23TestShapeRecursiveStructType) InputService23TestShapeRecursiveStructType { s.RecursiveMap = v return s } // SetRecursiveStruct sets the RecursiveStruct field's value. func (s InputService23TestShapeRecursiveStructType) SetRecursiveStruct(v InputService23TestShapeRecursiveStructType) InputService23TestShapeRecursiveStructType { s.RecursiveStruct = v return s } // InputService24ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService24ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService24ProtocolTest struct { client.Client } // New creates a new instance of the InputService24ProtocolTest 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 InputService24ProtocolTest client from just a session. // svc := inputservice24protocoltest.New(mySession) // // // Create a InputService24ProtocolTest client with additional configuration // svc := inputservice24protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService24ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService24ProtocolTest { c := p.ClientConfig("inputservice24protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService24ProtocolTestClient(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 newInputService24ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService24ProtocolTest { svc := &InputService24ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService24ProtocolTest", ServiceID: "InputService24ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService24ProtocolTest operation and runs any // custom request initialization. func (c InputService24ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService24TestCaseOperation1 = "OperationName" // InputService24TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService24TestCaseOperation1 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 InputService24TestCaseOperation1 for more information on using the InputService24TestCaseOperation1 // 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 InputService24TestCaseOperation1Request method. // req, resp := client.InputService24TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService24ProtocolTest) InputService24TestCaseOperation1Request(input InputService24TestShapeInputService24TestCaseOperation1Input) (req request.Request, output InputService24TestShapeInputService24TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService24TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService24TestShapeInputService24TestCaseOperation1Input{} } output = &InputService24TestShapeInputService24TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService24TestCaseOperation1 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 InputService24TestCaseOperation1 for usage and error information. func (c InputService24ProtocolTest) InputService24TestCaseOperation1(input InputService24TestShapeInputService24TestCaseOperation1Input) (InputService24TestShapeInputService24TestCaseOperation1Output, error) { req, out := c.InputService24TestCaseOperation1Request(input) return out, req.Send() } // InputService24TestCaseOperation1WithContext is the same as InputService24TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService24TestCaseOperation1 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 InputService24ProtocolTest) InputService24TestCaseOperation1WithContext(ctx aws.Context, input InputService24TestShapeInputService24TestCaseOperation1Input, opts ...request.Option) (InputService24TestShapeInputService24TestCaseOperation1Output, error) { req, out := c.InputService24TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService24TestCaseOperation2 = "OperationName" // InputService24TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the InputService24TestCaseOperation2 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 InputService24TestCaseOperation2 for more information on using the InputService24TestCaseOperation2 // 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 InputService24TestCaseOperation2Request method. // req, resp := client.InputService24TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService24ProtocolTest) InputService24TestCaseOperation2Request(input InputService24TestShapeInputService24TestCaseOperation2Input) (req request.Request, output InputService24TestShapeInputService24TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService24TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService24TestShapeInputService24TestCaseOperation2Input{} } output = &InputService24TestShapeInputService24TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService24TestCaseOperation2 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 InputService24TestCaseOperation2 for usage and error information. func (c InputService24ProtocolTest) InputService24TestCaseOperation2(input InputService24TestShapeInputService24TestCaseOperation2Input) (InputService24TestShapeInputService24TestCaseOperation2Output, error) { req, out := c.InputService24TestCaseOperation2Request(input) return out, req.Send() } // InputService24TestCaseOperation2WithContext is the same as InputService24TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See InputService24TestCaseOperation2 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 InputService24ProtocolTest) InputService24TestCaseOperation2WithContext(ctx aws.Context, input InputService24TestShapeInputService24TestCaseOperation2Input, opts ...request.Option) (InputService24TestShapeInputService24TestCaseOperation2Output, error) { req, out := c.InputService24TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService24TestShapeInputService24TestCaseOperation1Input struct { _ struct{} `locationName:"InputShape" type:"structure"` Token string `type:"string" idempotencyToken:"true"` } // SetToken sets the Token field's value. func (s InputService24TestShapeInputService24TestCaseOperation1Input) SetToken(v string) InputService24TestShapeInputService24TestCaseOperation1Input { s.Token = &v return s } type InputService24TestShapeInputService24TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService24TestShapeInputService24TestCaseOperation2Input struct { _ struct{} `locationName:"InputShape" type:"structure"` Token string `type:"string" idempotencyToken:"true"` } // SetToken sets the Token field's value. func (s InputService24TestShapeInputService24TestCaseOperation2Input) SetToken(v string) InputService24TestShapeInputService24TestCaseOperation2Input { s.Token = &v return s } type InputService24TestShapeInputService24TestCaseOperation2Output struct { _ struct{} `type:"structure"` } // InputService25ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService25ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService25ProtocolTest struct { client.Client } // New creates a new instance of the InputService25ProtocolTest 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 InputService25ProtocolTest client from just a session. // svc := inputservice25protocoltest.New(mySession) // // // Create a InputService25ProtocolTest client with additional configuration // svc := inputservice25protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService25ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService25ProtocolTest { c := p.ClientConfig("inputservice25protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService25ProtocolTestClient(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 newInputService25ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService25ProtocolTest { svc := &InputService25ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService25ProtocolTest", ServiceID: "InputService25ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService25ProtocolTest operation and runs any // custom request initialization. func (c InputService25ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService25TestCaseOperation1 = "OperationName" // InputService25TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService25TestCaseOperation1 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 InputService25TestCaseOperation1 for more information on using the InputService25TestCaseOperation1 // 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 InputService25TestCaseOperation1Request method. // req, resp := client.InputService25TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService25ProtocolTest) InputService25TestCaseOperation1Request(input InputService25TestShapeInputService25TestCaseOperation1Input) (req request.Request, output InputService25TestShapeInputService25TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService25TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/Enum/{URIEnum}", } if input == nil { input = &InputService25TestShapeInputService25TestCaseOperation1Input{} } output = &InputService25TestShapeInputService25TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService25TestCaseOperation1 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 InputService25TestCaseOperation1 for usage and error information. func (c InputService25ProtocolTest) InputService25TestCaseOperation1(input InputService25TestShapeInputService25TestCaseOperation1Input) (InputService25TestShapeInputService25TestCaseOperation1Output, error) { req, out := c.InputService25TestCaseOperation1Request(input) return out, req.Send() } // InputService25TestCaseOperation1WithContext is the same as InputService25TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService25TestCaseOperation1 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 InputService25ProtocolTest) InputService25TestCaseOperation1WithContext(ctx aws.Context, input InputService25TestShapeInputService25TestCaseOperation1Input, opts ...request.Option) (InputService25TestShapeInputService25TestCaseOperation1Output, error) { req, out := c.InputService25TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService25TestCaseOperation2 = "OperationName" // InputService25TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the InputService25TestCaseOperation2 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 InputService25TestCaseOperation2 for more information on using the InputService25TestCaseOperation2 // 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 InputService25TestCaseOperation2Request method. // req, resp := client.InputService25TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService25ProtocolTest) InputService25TestCaseOperation2Request(input InputService25TestShapeInputService25TestCaseOperation2Input) (req request.Request, output InputService25TestShapeInputService25TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService25TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/Enum/{URIEnum}", } if input == nil { input = &InputService25TestShapeInputService25TestCaseOperation2Input{} } output = &InputService25TestShapeInputService25TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService25TestCaseOperation2 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 InputService25TestCaseOperation2 for usage and error information. func (c InputService25ProtocolTest) InputService25TestCaseOperation2(input InputService25TestShapeInputService25TestCaseOperation2Input) (InputService25TestShapeInputService25TestCaseOperation2Output, error) { req, out := c.InputService25TestCaseOperation2Request(input) return out, req.Send() } // InputService25TestCaseOperation2WithContext is the same as InputService25TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See InputService25TestCaseOperation2 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 InputService25ProtocolTest) InputService25TestCaseOperation2WithContext(ctx aws.Context, input InputService25TestShapeInputService25TestCaseOperation2Input, opts ...request.Option) (InputService25TestShapeInputService25TestCaseOperation2Output, error) { req, out := c.InputService25TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService25TestShapeInputService25TestCaseOperation1Input struct { _ struct{} `locationName:"InputShape" type:"structure"` FooEnum string `type:"string" enum:"InputService25TestShapeEnumType"` HeaderEnum string `location:"header" locationName:"x-amz-enum" type:"string" enum:"InputService25TestShapeEnumType"` ListEnums []string `type:"list" enum:"InputService25TestShapeEnumType"` // URIFooEnum is a required field URIFooEnum string `location:"uri" locationName:"URIEnum" type:"string" required:"true" enum:"InputService25TestShapeEnumType"` URIListEnums []string `location:"querystring" locationName:"ListEnums" type:"list" enum:"InputService25TestShapeEnumType"` } // Validate inspects the fields of the type to determine if they are valid. func (s InputService25TestShapeInputService25TestCaseOperation1Input) Validate() error { invalidParams := request.ErrInvalidParams{Context: "InputService25TestShapeInputService25TestCaseOperation1Input"} if s.URIFooEnum == nil { invalidParams.Add(request.NewErrParamRequired("URIFooEnum")) } if s.URIFooEnum != nil && len(s.URIFooEnum) < 1 { invalidParams.Add(request.NewErrParamMinLen("URIFooEnum", 1)) } if invalidParams.Len() > 0 { return invalidParams } return nil } // SetFooEnum sets the FooEnum field's value. func (s InputService25TestShapeInputService25TestCaseOperation1Input) SetFooEnum(v string) InputService25TestShapeInputService25TestCaseOperation1Input { s.FooEnum = &v return s } // SetHeaderEnum sets the HeaderEnum field's value. func (s InputService25TestShapeInputService25TestCaseOperation1Input) SetHeaderEnum(v string) InputService25TestShapeInputService25TestCaseOperation1Input { s.HeaderEnum = &v return s } // SetListEnums sets the ListEnums field's value. func (s InputService25TestShapeInputService25TestCaseOperation1Input) SetListEnums(v []string) InputService25TestShapeInputService25TestCaseOperation1Input { s.ListEnums = v return s } // SetURIFooEnum sets the URIFooEnum field's value. func (s InputService25TestShapeInputService25TestCaseOperation1Input) SetURIFooEnum(v string) InputService25TestShapeInputService25TestCaseOperation1Input { s.URIFooEnum = &v return s } // SetURIListEnums sets the URIListEnums field's value. func (s InputService25TestShapeInputService25TestCaseOperation1Input) SetURIListEnums(v []string) InputService25TestShapeInputService25TestCaseOperation1Input { s.URIListEnums = v return s } type InputService25TestShapeInputService25TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService25TestShapeInputService25TestCaseOperation2Input struct { _ struct{} `locationName:"InputShape" type:"structure"` FooEnum string `type:"string" enum:"InputService25TestShapeEnumType"` HeaderEnum string `location:"header" locationName:"x-amz-enum" type:"string" enum:"InputService25TestShapeEnumType"` ListEnums []string `type:"list" enum:"InputService25TestShapeEnumType"` // URIFooEnum is a required field URIFooEnum string `location:"uri" locationName:"URIEnum" type:"string" required:"true" enum:"InputService25TestShapeEnumType"` URIListEnums []string `location:"querystring" locationName:"ListEnums" type:"list" enum:"InputService25TestShapeEnumType"` } // Validate inspects the fields of the type to determine if they are valid. func (s InputService25TestShapeInputService25TestCaseOperation2Input) Validate() error { invalidParams := request.ErrInvalidParams{Context: "InputService25TestShapeInputService25TestCaseOperation2Input"} if s.URIFooEnum == nil { invalidParams.Add(request.NewErrParamRequired("URIFooEnum")) } if s.URIFooEnum != nil && len(s.URIFooEnum) < 1 { invalidParams.Add(request.NewErrParamMinLen("URIFooEnum", 1)) } if invalidParams.Len() > 0 { return invalidParams } return nil } // SetFooEnum sets the FooEnum field's value. func (s InputService25TestShapeInputService25TestCaseOperation2Input) SetFooEnum(v string) InputService25TestShapeInputService25TestCaseOperation2Input { s.FooEnum = &v return s } // SetHeaderEnum sets the HeaderEnum field's value. func (s InputService25TestShapeInputService25TestCaseOperation2Input) SetHeaderEnum(v string) InputService25TestShapeInputService25TestCaseOperation2Input { s.HeaderEnum = &v return s } // SetListEnums sets the ListEnums field's value. func (s InputService25TestShapeInputService25TestCaseOperation2Input) SetListEnums(v []string) InputService25TestShapeInputService25TestCaseOperation2Input { s.ListEnums = v return s } // SetURIFooEnum sets the URIFooEnum field's value. func (s InputService25TestShapeInputService25TestCaseOperation2Input) SetURIFooEnum(v string) InputService25TestShapeInputService25TestCaseOperation2Input { s.URIFooEnum = &v return s } // SetURIListEnums sets the URIListEnums field's value. func (s InputService25TestShapeInputService25TestCaseOperation2Input) SetURIListEnums(v []string) InputService25TestShapeInputService25TestCaseOperation2Input { s.URIListEnums = v return s } type InputService25TestShapeInputService25TestCaseOperation2Output struct { _ struct{} `type:"structure"` } const ( // EnumTypeFoo is a InputService25TestShapeEnumType enum value EnumTypeFoo = "foo" // EnumTypeBar is a InputService25TestShapeEnumType enum value EnumTypeBar = "bar" // EnumType0 is a InputService25TestShapeEnumType enum value EnumType0 = "0" // EnumType1 is a InputService25TestShapeEnumType enum value EnumType1 = "1" ) // InputService25TestShapeEnumType_Values returns all elements of the InputService25TestShapeEnumType enum func InputService25TestShapeEnumType_Values() []string { return []string{ EnumTypeFoo, EnumTypeBar, EnumType0, EnumType1, } } // InputService26ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService26ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService26ProtocolTest struct { client.Client } // New creates a new instance of the InputService26ProtocolTest 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 InputService26ProtocolTest client from just a session. // svc := inputservice26protocoltest.New(mySession) // // // Create a InputService26ProtocolTest client with additional configuration // svc := inputservice26protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService26ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService26ProtocolTest { c := p.ClientConfig("inputservice26protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService26ProtocolTestClient(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 newInputService26ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService26ProtocolTest { svc := &InputService26ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService26ProtocolTest", ServiceID: "InputService26ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService26ProtocolTest operation and runs any // custom request initialization. func (c InputService26ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService26TestCaseOperation1 = "StaticOp" // InputService26TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService26TestCaseOperation1 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 InputService26TestCaseOperation1 for more information on using the InputService26TestCaseOperation1 // 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 InputService26TestCaseOperation1Request method. // req, resp := client.InputService26TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService26ProtocolTest) InputService26TestCaseOperation1Request(input InputService26TestShapeInputService26TestCaseOperation1Input) (req request.Request, output InputService26TestShapeInputService26TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService26TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService26TestShapeInputService26TestCaseOperation1Input{} } output = &InputService26TestShapeInputService26TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) req.Handlers.Build.PushBackNamed(protocol.NewHostPrefixHandler("data-", nil)) req.Handlers.Build.PushBackNamed(protocol.ValidateEndpointHostHandler) return } // InputService26TestCaseOperation1 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 InputService26TestCaseOperation1 for usage and error information. func (c InputService26ProtocolTest) InputService26TestCaseOperation1(input InputService26TestShapeInputService26TestCaseOperation1Input) (InputService26TestShapeInputService26TestCaseOperation1Output, error) { req, out := c.InputService26TestCaseOperation1Request(input) return out, req.Send() } // InputService26TestCaseOperation1WithContext is the same as InputService26TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService26TestCaseOperation1 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 InputService26ProtocolTest) InputService26TestCaseOperation1WithContext(ctx aws.Context, input InputService26TestShapeInputService26TestCaseOperation1Input, opts ...request.Option) (InputService26TestShapeInputService26TestCaseOperation1Output, error) { req, out := c.InputService26TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opInputService26TestCaseOperation2 = "MemberRefOp" // InputService26TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the InputService26TestCaseOperation2 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 InputService26TestCaseOperation2 for more information on using the InputService26TestCaseOperation2 // 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 InputService26TestCaseOperation2Request method. // req, resp := client.InputService26TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService26ProtocolTest) InputService26TestCaseOperation2Request(input InputService26TestShapeInputService26TestCaseOperation2Input) (req request.Request, output InputService26TestShapeInputService26TestCaseOperation2Output) { op := &request.Operation{ Name: opInputService26TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &InputService26TestShapeInputService26TestCaseOperation2Input{} } output = &InputService26TestShapeInputService26TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) req.Handlers.Build.PushBackNamed(protocol.NewHostPrefixHandler("foo-{Name}.", input.hostLabels)) req.Handlers.Build.PushBackNamed(protocol.ValidateEndpointHostHandler) return } // InputService26TestCaseOperation2 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 InputService26TestCaseOperation2 for usage and error information. func (c InputService26ProtocolTest) InputService26TestCaseOperation2(input InputService26TestShapeInputService26TestCaseOperation2Input) (InputService26TestShapeInputService26TestCaseOperation2Output, error) { req, out := c.InputService26TestCaseOperation2Request(input) return out, req.Send() } // InputService26TestCaseOperation2WithContext is the same as InputService26TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See InputService26TestCaseOperation2 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 InputService26ProtocolTest) InputService26TestCaseOperation2WithContext(ctx aws.Context, input InputService26TestShapeInputService26TestCaseOperation2Input, opts ...request.Option) (InputService26TestShapeInputService26TestCaseOperation2Output, error) { req, out := c.InputService26TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService26TestShapeInputService26TestCaseOperation1Input struct { _ struct{} `locationName:"StaticOpRequest" type:"structure"` Name string `type:"string"` } // SetName sets the Name field's value. func (s InputService26TestShapeInputService26TestCaseOperation1Input) SetName(v string) InputService26TestShapeInputService26TestCaseOperation1Input { s.Name = &v return s } type InputService26TestShapeInputService26TestCaseOperation1Output struct { _ struct{} `type:"structure"` } type InputService26TestShapeInputService26TestCaseOperation2Input struct { _ struct{} `locationName:"MemberRefOpRequest" 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 InputService26TestShapeInputService26TestCaseOperation2Input) Validate() error { invalidParams := request.ErrInvalidParams{Context: "InputService26TestShapeInputService26TestCaseOperation2Input"} 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 InputService26TestShapeInputService26TestCaseOperation2Input) SetName(v string) InputService26TestShapeInputService26TestCaseOperation2Input { s.Name = &v return s } func (s InputService26TestShapeInputService26TestCaseOperation2Input) hostLabels() map[string]string { return map[string]string{ "Name": aws.StringValue(s.Name), } } type InputService26TestShapeInputService26TestCaseOperation2Output struct { _ struct{} `type:"structure"` } // InputService27ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // InputService27ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type InputService27ProtocolTest struct { client.Client } // New creates a new instance of the InputService27ProtocolTest 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 InputService27ProtocolTest client from just a session. // svc := inputservice27protocoltest.New(mySession) // // // Create a InputService27ProtocolTest client with additional configuration // svc := inputservice27protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewInputService27ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) InputService27ProtocolTest { c := p.ClientConfig("inputservice27protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newInputService27ProtocolTestClient(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 newInputService27ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) InputService27ProtocolTest { svc := &InputService27ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "InputService27ProtocolTest", ServiceID: "InputService27ProtocolTest", 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a InputService27ProtocolTest operation and runs any // custom request initialization. func (c InputService27ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opInputService27TestCaseOperation1 = "OperationName" // InputService27TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the InputService27TestCaseOperation1 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 InputService27TestCaseOperation1 for more information on using the InputService27TestCaseOperation1 // 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 InputService27TestCaseOperation1Request method. // req, resp := client.InputService27TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c InputService27ProtocolTest) InputService27TestCaseOperation1Request(input InputService27TestShapeInputService27TestCaseOperation1Input) (req request.Request, output InputService27TestShapeInputService27TestCaseOperation1Output) { op := &request.Operation{ Name: opInputService27TestCaseOperation1, HTTPMethod: "GET", HTTPPath: "/", } if input == nil { input = &InputService27TestShapeInputService27TestCaseOperation1Input{} } output = &InputService27TestShapeInputService27TestCaseOperation1Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // InputService27TestCaseOperation1 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 InputService27TestCaseOperation1 for usage and error information. func (c InputService27ProtocolTest) InputService27TestCaseOperation1(input InputService27TestShapeInputService27TestCaseOperation1Input) (InputService27TestShapeInputService27TestCaseOperation1Output, error) { req, out := c.InputService27TestCaseOperation1Request(input) return out, req.Send() } // InputService27TestCaseOperation1WithContext is the same as InputService27TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See InputService27TestCaseOperation1 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 InputService27ProtocolTest) InputService27TestCaseOperation1WithContext(ctx aws.Context, input InputService27TestShapeInputService27TestCaseOperation1Input, opts ...request.Option) (InputService27TestShapeInputService27TestCaseOperation1Output, error) { req, out := c.InputService27TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type InputService27TestShapeInputService27TestCaseOperation1Input struct { _ struct{} `locationName:"InputShape" type:"structure"` Header1 string `location:"header" type:"string"` HeaderMap map[string]string `location:"headers" locationName:"header-map-" type:"map"` } // SetHeader1 sets the Header1 field's value. func (s InputService27TestShapeInputService27TestCaseOperation1Input) SetHeader1(v string) InputService27TestShapeInputService27TestCaseOperation1Input { s.Header1 = &v return s } // SetHeaderMap sets the HeaderMap field's value. func (s InputService27TestShapeInputService27TestCaseOperation1Input) SetHeaderMap(v map[string]string) InputService27TestShapeInputService27TestCaseOperation1Input { s.HeaderMap = v return s } type InputService27TestShapeInputService27TestCaseOperation1Output struct { _ struct{} `type:"structure"` } // // Tests begin here // func TestInputService1ProtocolTestBasicXMLSerializationCase1(t testing.T) { svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService1TestShapeInputService1TestCaseOperation1Input{ Description: aws.String("bar"), Name: aws.String("foo"), } 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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><Name>foo</Name><Description>bar</Description></OperationRequest>`, 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/2014-01-01/hostedzone", r.URL.String()) } func TestInputService1ProtocolTestBasicXMLSerializationCase2(t testing.T) { svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService1TestShapeInputService1TestCaseOperation2Input{ Description: aws.String("bar"), Name: aws.String("foo"), } req, _ := svc.InputService1TestCaseOperation2Request(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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><Name>foo</Name><Description>bar</Description></OperationRequest>`, 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/2014-01-01/hostedzone", r.URL.String()) } func TestInputService1ProtocolTestBasicXMLSerializationCase3(t testing.T) { svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService1TestShapeInputService1TestCaseOperation3Input{} req, _ := svc.InputService1TestCaseOperation3Request(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/2014-01-01/hostedzone", r.URL.String()) } func TestInputService2ProtocolTestSerializeOtherScalarTypesCase1(t testing.T) { svc := NewInputService2ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService2TestShapeInputService2TestCaseOperation1Input{ First: aws.Bool(true), Fourth: aws.Int64(3), Second: aws.Bool(false), Third: aws.Float64(1.2), } req, _ := svc.InputService2TestCaseOperation1Request(input) r := req.HTTPRequest // build request 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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><First>true</First><Second>false</Second><Third>1.2</Third><Fourth>3</Fourth></OperationRequest>`, 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/2014-01-01/hostedzone", r.URL.String()) } func TestInputService3ProtocolTestNestedStructuresCase1(t testing.T) { svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService3TestShapeInputService3TestCaseOperation1Input{ Description: aws.String("baz"), SubStructure: &InputService3TestShapeSubStructure{ Bar: aws.String("b"), Foo: aws.String("a"), }, } req, _ := svc.InputService3TestCaseOperation1Request(input) r := req.HTTPRequest // build request 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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><SubStructure><Foo>a</Foo><Bar>b</Bar></SubStructure><Description>baz</Description></OperationRequest>`, 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/2014-01-01/hostedzone", r.URL.String()) } func TestInputService3ProtocolTestNestedStructuresCase2(t testing.T) { svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService3TestShapeInputService3TestCaseOperation2Input{ Description: aws.String("baz"), SubStructure: &InputService3TestShapeSubStructure{ Foo: aws.String("a"), }, } 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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><SubStructure><Foo>a</Foo></SubStructure><Description>baz</Description></OperationRequest>`, 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/2014-01-01/hostedzone", r.URL.String()) } func TestInputService4ProtocolTestNestedStructuresCase1(t testing.T) { svc := NewInputService4ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService4TestShapeInputService4TestCaseOperation1Input{ Description: aws.String("baz"), SubStructure: &InputService4TestShapeSubStructure{}, } 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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><SubStructure /><Description>baz</Description></OperationRequest>`, 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/2014-01-01/hostedzone", r.URL.String()) } func TestInputService5ProtocolTestNonFlattenedListsCase1(t testing.T) { svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService5TestShapeInputService5TestCaseOperation1Input{ ListParam: []string{ aws.String("one"), aws.String("two"), aws.String("three"), }, } 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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><ListParam><member>one</member><member>two</member><member>three</member></ListParam></OperationRequest>`, 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/2014-01-01/hostedzone", r.URL.String()) } func TestInputService6ProtocolTestNonFlattenedListsWithLocationNameCase1(t testing.T) { svc := NewInputService6ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService6TestShapeInputService6TestCaseOperation1Input{ ListParam: []string{ aws.String("one"), aws.String("two"), aws.String("three"), }, } 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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><AlternateName><NotMember>one</NotMember><NotMember>two</NotMember><NotMember>three</NotMember></AlternateName></OperationRequest>`, 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/2014-01-01/hostedzone", r.URL.String()) } func TestInputService7ProtocolTestFlattenedListsCase1(t testing.T) { svc := NewInputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService7TestShapeInputService7TestCaseOperation1Input{ ListParam: []string{ aws.String("one"), aws.String("two"), aws.String("three"), }, } 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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><ListParam>one</ListParam><ListParam>two</ListParam><ListParam>three</ListParam></OperationRequest>`, 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/2014-01-01/hostedzone", r.URL.String()) } func TestInputService8ProtocolTestFlattenedListsWithLocationNameCase1(t testing.T) { svc := NewInputService8ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService8TestShapeInputService8TestCaseOperation1Input{ ListParam: []string{ aws.String("one"), aws.String("two"), aws.String("three"), }, } 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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><item>one</item><item>two</item><item>three</item></OperationRequest>`, 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/2014-01-01/hostedzone", r.URL.String()) } func TestInputService9ProtocolTestListOfStructuresCase1(t testing.T) { svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService9TestShapeInputService9TestCaseOperation1Input{ ListParam: []InputService9TestShapeSingleFieldStruct{ { Element: aws.String("one"), }, { Element: aws.String("two"), }, { Element: aws.String("three"), }, }, } req, _ := svc.InputService9TestCaseOperation1Request(input) r := req.HTTPRequest // build request 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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><item><value>one</value></item><item><value>two</value></item><item><value>three</value></item></OperationRequest>`, 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/2014-01-01/hostedzone", r.URL.String()) } func TestInputService10ProtocolTestBlobShapesCase1(t testing.T) { svc := NewInputService10ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService10TestShapeInputService10TestCaseOperation1Input{ StructureParam: &InputService10TestShapeStructureShape{ B: []byte("foo"), }, } req, _ := svc.InputService10TestCaseOperation1Request(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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><StructureParam><b>Zm9v</b></StructureParam></OperationRequest>`, 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/2014-01-01/hostedzone", r.URL.String()) } func TestInputService11ProtocolTestTimestampShapesCase1(t testing.T) { svc := NewInputService11ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService11TestShapeInputService11TestCaseOperation1Input{ TimeArg: aws.Time(time.Unix(1422172800, 0)), TimeArgInHeader: aws.Time(time.Unix(1422172800, 0)), TimeArgInQuery: aws.Time(time.Unix(1422172800, 0)), TimeCustom: aws.Time(time.Unix(1422172800, 0)), TimeCustomInHeader: aws.Time(time.Unix(1422172800, 0)), TimeCustomInQuery: aws.Time(time.Unix(1422172800, 0)), TimeFormat: aws.Time(time.Unix(1422172800, 0)), TimeFormatInHeader: aws.Time(time.Unix(1422172800, 0)), TimeFormatInQuery: aws.Time(time.Unix(1422172800, 0)), } req, _ := svc.InputService11TestCaseOperation1Request(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.AssertXML(t, `<TimestampStructure xmlns="https://foo/"><TimeArg>2015-01-25T08:00:00Z</TimeArg><TimeCustom>Sun, 25 Jan 2015 08:00:00 GMT</TimeCustom><TimeFormat>Sun, 25 Jan 2015 08:00:00 GMT</TimeFormat></TimestampStructure>`, 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/2014-01-01/hostedzone?TimeQuery=2015-01-25T08%3A00%3A00Z&TimeCustomQuery=1422172800&TimeFormatQuery=1422172800", r.URL.String()) // assert headers if e, a := "Sun, 25 Jan 2015 08:00:00 GMT", r.Header.Get("x-amz-timearg"); e != a { t.Errorf("expect x-amz-timearg %v header value, got %v", e, a) } if e, a := "1422172800", r.Header.Get("x-amz-timecustom-header"); e != a { t.Errorf("expect x-amz-timecustom-header %v header value, got %v", e, a) } if e, a := "1422172800", r.Header.Get("x-amz-timeformat-header"); e != a { t.Errorf("expect x-amz-timeformat-header %v header value, got %v", e, a) } } func TestInputService12ProtocolTestHeaderMapsCase1(t testing.T) { svc := NewInputService12ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService12TestShapeInputService12TestCaseOperation1Input{ Foo: map[string]string{ "a": aws.String("b"), "c": aws.String("d"), }, } req, _ := svc.InputService12TestCaseOperation1Request(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()) // assert headers if e, a := "b", r.Header.Get("x-foo-a"); e != a { t.Errorf("expect x-foo-a %v header value, got %v", e, a) } if e, a := "d", r.Header.Get("x-foo-c"); e != a { t.Errorf("expect x-foo-c %v header value, got %v", e, a) } } func TestInputService13ProtocolTestQuerystringListOfStringsCase1(t testing.T) { svc := NewInputService13ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService13TestShapeInputService13TestCaseOperation1Input{ Items: []string{ aws.String("value1"), aws.String("value2"), }, } req, _ := svc.InputService13TestCaseOperation1Request(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/path?item=value1&item=value2", r.URL.String()) } func TestInputService14ProtocolTestStringToStringMapsInQuerystringCase1(t testing.T) { svc := NewInputService14ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService14TestShapeInputService14TestCaseOperation1Input{ PipelineId: aws.String("foo"), QueryDoc: map[string]string{ "bar": aws.String("baz"), "fizz": aws.String("buzz"), }, } req, _ := svc.InputService14TestCaseOperation1Request(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/2014-01-01/jobsByPipeline/foo?bar=baz&fizz=buzz", r.URL.String()) } func TestInputService15ProtocolTestStringToStringListMapsInQuerystringCase1(t testing.T) { svc := NewInputService15ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService15TestShapeInputService15TestCaseOperation1Input{ PipelineId: aws.String("id"), QueryDoc: map[string][]string{ "fizz": { aws.String("buzz"), aws.String("pop"), }, "foo": { aws.String("bar"), aws.String("baz"), }, }, } req, _ := svc.InputService15TestCaseOperation1Request(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/2014-01-01/jobsByPipeline/id?foo=bar&foo=baz&fizz=buzz&fizz=pop", r.URL.String()) } func TestInputService16ProtocolTestBooleanInQuerystringCase1(t testing.T) { svc := NewInputService16ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService16TestShapeInputService16TestCaseOperation1Input{ BoolQuery: aws.Bool(true), } req, _ := svc.InputService16TestCaseOperation1Request(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/path?bool-query=true", r.URL.String()) } func TestInputService16ProtocolTestBooleanInQuerystringCase2(t testing.T) { svc := NewInputService16ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService16TestShapeInputService16TestCaseOperation2Input{ BoolQuery: aws.Bool(false), } req, _ := svc.InputService16TestCaseOperation2Request(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/path?bool-query=false", r.URL.String()) } func TestInputService17ProtocolTestStringPayloadCase1(t testing.T) { svc := NewInputService17ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService17TestShapeInputService17TestCaseOperation1Input{ Foo: aws.String("bar"), } req, _ := svc.InputService17TestCaseOperation1Request(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) if e, a := "bar", util.Trim(string(body)); e != a { t.Errorf("expect %v, got %v", e, a) } 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 TestInputService18ProtocolTestBlobPayloadCase1(t testing.T) { svc := NewInputService18ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService18TestShapeInputService18TestCaseOperation1Input{ Foo: []byte("bar"), } req, _ := svc.InputService18TestCaseOperation1Request(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) if e, a := "bar", util.Trim(string(body)); e != a { t.Errorf("expect %v, got %v", e, a) } 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 TestInputService18ProtocolTestBlobPayloadCase2(t testing.T) { svc := NewInputService18ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService18TestShapeInputService18TestCaseOperation2Input{} req, _ := svc.InputService18TestCaseOperation2Request(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 TestInputService19ProtocolTestStructurePayloadCase1(t testing.T) { svc := NewInputService19ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService19TestShapeInputService19TestCaseOperation1Input{ Foo: &InputService19TestShapeFooShape{ Baz: aws.String("bar"), }, } req, _ := svc.InputService19TestCaseOperation1Request(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.AssertXML(t, `<foo><baz>bar</baz></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()) } func TestInputService19ProtocolTestStructurePayloadCase2(t testing.T) { svc := NewInputService19ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService19TestShapeInputService19TestCaseOperation2Input{} req, _ := svc.InputService19TestCaseOperation2Request(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 TestInputService19ProtocolTestStructurePayloadCase3(t testing.T) { svc := NewInputService19ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService19TestShapeInputService19TestCaseOperation3Input{ Foo: &InputService19TestShapeFooShape{}, } req, _ := svc.InputService19TestCaseOperation3Request(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.AssertXML(t, `<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()) } func TestInputService19ProtocolTestStructurePayloadCase4(t testing.T) { svc := NewInputService19ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService19TestShapeInputService19TestCaseOperation4Input{} req, _ := svc.InputService19TestCaseOperation4Request(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 TestInputService20ProtocolTestXMLAttributeCase1(t testing.T) { svc := NewInputService20ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService20TestShapeInputService20TestCaseOperation1Input{ Grant: &InputService20TestShapeGrant{ Grantee: &InputService20TestShapeGrantee{ EmailAddress: aws.String("foo@example.com"), Type: aws.String("CanonicalUser"), }, }, } req, _ := svc.InputService20TestCaseOperation1Request(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.AssertXML(t, `<Grant><Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser"><EmailAddress>foo@example.com</EmailAddress></Grantee></Grant>`, 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 TestInputService21ProtocolTestGreedyKeysCase1(t testing.T) { svc := NewInputService21ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService21TestShapeInputService21TestCaseOperation1Input{ Bucket: aws.String("my/bucket"), Key: aws.String("testing /123"), } req, _ := svc.InputService21TestCaseOperation1Request(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/my%2Fbucket/testing%20/123", r.URL.String()) } func TestInputService22ProtocolTestOmitsNullQueryParamsButSerializesEmptyStringsCase1(t testing.T) { svc := NewInputService22ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService22TestShapeInputService22TestCaseOperation1Input{} req, _ := svc.InputService22TestCaseOperation1Request(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/path", r.URL.String()) } func TestInputService22ProtocolTestOmitsNullQueryParamsButSerializesEmptyStringsCase2(t testing.T) { svc := NewInputService22ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService22TestShapeInputService22TestCaseOperation2Input{ Foo: aws.String(""), } req, _ := svc.InputService22TestCaseOperation2Request(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/path?abc=mno&param-name=", r.URL.String()) } func TestInputService23ProtocolTestRecursiveShapesCase1(t testing.T) { svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService23TestShapeInputService23TestCaseOperation1Input{ RecursiveStruct: &InputService23TestShapeRecursiveStructType{ NoRecurse: aws.String("foo"), }, } req, _ := svc.InputService23TestCaseOperation1Request(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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><RecursiveStruct><NoRecurse>foo</NoRecurse></RecursiveStruct></OperationRequest>`, 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/path", r.URL.String()) } func TestInputService23ProtocolTestRecursiveShapesCase2(t testing.T) { svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService23TestShapeInputService23TestCaseOperation2Input{ RecursiveStruct: &InputService23TestShapeRecursiveStructType{ RecursiveStruct: &InputService23TestShapeRecursiveStructType{ NoRecurse: aws.String("foo"), }, }, } req, _ := svc.InputService23TestCaseOperation2Request(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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><RecursiveStruct><RecursiveStruct><NoRecurse>foo</NoRecurse></RecursiveStruct></RecursiveStruct></OperationRequest>`, 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/path", r.URL.String()) } func TestInputService23ProtocolTestRecursiveShapesCase3(t testing.T) { svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService23TestShapeInputService23TestCaseOperation3Input{ RecursiveStruct: &InputService23TestShapeRecursiveStructType{ RecursiveStruct: &InputService23TestShapeRecursiveStructType{ RecursiveStruct: &InputService23TestShapeRecursiveStructType{ RecursiveStruct: &InputService23TestShapeRecursiveStructType{ NoRecurse: aws.String("foo"), }, }, }, }, } req, _ := svc.InputService23TestCaseOperation3Request(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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><RecursiveStruct><RecursiveStruct><RecursiveStruct><RecursiveStruct><NoRecurse>foo</NoRecurse></RecursiveStruct></RecursiveStruct></RecursiveStruct></RecursiveStruct></OperationRequest>`, 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/path", r.URL.String()) } func TestInputService23ProtocolTestRecursiveShapesCase4(t testing.T) { svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService23TestShapeInputService23TestCaseOperation4Input{ RecursiveStruct: &InputService23TestShapeRecursiveStructType{ RecursiveList: []InputService23TestShapeRecursiveStructType{ { NoRecurse: aws.String("foo"), }, { NoRecurse: aws.String("bar"), }, }, }, } req, _ := svc.InputService23TestCaseOperation4Request(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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><RecursiveStruct><RecursiveList><member><NoRecurse>foo</NoRecurse></member><member><NoRecurse>bar</NoRecurse></member></RecursiveList></RecursiveStruct></OperationRequest>`, 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/path", r.URL.String()) } func TestInputService23ProtocolTestRecursiveShapesCase5(t testing.T) { svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService23TestShapeInputService23TestCaseOperation5Input{ RecursiveStruct: &InputService23TestShapeRecursiveStructType{ RecursiveList: []InputService23TestShapeRecursiveStructType{ { NoRecurse: aws.String("foo"), }, { RecursiveStruct: &InputService23TestShapeRecursiveStructType{ NoRecurse: aws.String("bar"), }, }, }, }, } req, _ := svc.InputService23TestCaseOperation5Request(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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><RecursiveStruct><RecursiveList><member><NoRecurse>foo</NoRecurse></member><member><RecursiveStruct><NoRecurse>bar</NoRecurse></RecursiveStruct></member></RecursiveList></RecursiveStruct></OperationRequest>`, 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/path", r.URL.String()) } func TestInputService23ProtocolTestRecursiveShapesCase6(t testing.T) { svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService23TestShapeInputService23TestCaseOperation6Input{ RecursiveStruct: &InputService23TestShapeRecursiveStructType{ RecursiveMap: map[string]InputService23TestShapeRecursiveStructType{ "bar": { NoRecurse: aws.String("bar"), }, "foo": { NoRecurse: aws.String("foo"), }, }, }, } req, _ := svc.InputService23TestCaseOperation6Request(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.AssertXML(t, `<OperationRequest xmlns="https://foo/"><RecursiveStruct><RecursiveMap><entry><key>bar</key><value><NoRecurse>bar</NoRecurse></value></entry><entry><key>foo</key><value><NoRecurse>foo</NoRecurse></value></entry></RecursiveMap></RecursiveStruct></OperationRequest>`, 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/path", r.URL.String()) } func TestInputService24ProtocolTestIdempotencyTokenAutoFillCase1(t testing.T) { svc := NewInputService24ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService24TestShapeInputService24TestCaseOperation1Input{ Token: aws.String("abc123"), } req, _ := svc.InputService24TestCaseOperation1Request(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.AssertXML(t, `<InputShape><Token>abc123</Token></InputShape>`, 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/path", r.URL.String()) } func TestInputService24ProtocolTestIdempotencyTokenAutoFillCase2(t testing.T) { svc := NewInputService24ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService24TestShapeInputService24TestCaseOperation2Input{} req, _ := svc.InputService24TestCaseOperation2Request(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.AssertXML(t, `<InputShape><Token>00000000-0000-4000-8000-000000000000</Token></InputShape>`, 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/path", r.URL.String()) } func TestInputService25ProtocolTestEnumCase1(t testing.T) { svc := NewInputService25ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService25TestShapeInputService25TestCaseOperation1Input{ FooEnum: aws.String("foo"), HeaderEnum: aws.String("baz"), ListEnums: []string{ aws.String("foo"), aws.String(""), aws.String("bar"), }, URIFooEnum: aws.String("bar"), URIListEnums: []string{ aws.String("0"), aws.String(""), aws.String("1"), }, } req, _ := svc.InputService25TestCaseOperation1Request(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.AssertXML(t, `<InputShape><FooEnum>foo</FooEnum><ListEnums><member>foo</member><member></member><member>bar</member></ListEnums></InputShape>`, 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/Enum/bar?ListEnums=0&ListEnums=&ListEnums=1", r.URL.String()) // assert headers if e, a := "baz", r.Header.Get("x-amz-enum"); e != a { t.Errorf("expect x-amz-enum %v header value, got %v", e, a) } } func TestInputService25ProtocolTestEnumCase2(t testing.T) { svc := NewInputService25ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService25TestShapeInputService25TestCaseOperation2Input{ URIFooEnum: aws.String("bar"), } req, _ := svc.InputService25TestCaseOperation2Request(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/Enum/bar", r.URL.String()) } func TestInputService26ProtocolTestEndpointHostTraitCase1(t testing.T) { svc := NewInputService26ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://service.region.amazonaws.com")}) input := &InputService26TestShapeInputService26TestCaseOperation1Input{ Name: aws.String("myname"), } req, _ := svc.InputService26TestCaseOperation1Request(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.AssertXML(t, `<StaticOpRequest><Name>myname</Name></StaticOpRequest>`, 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/path", r.URL.String()) } func TestInputService26ProtocolTestEndpointHostTraitCase2(t testing.T) { svc := NewInputService26ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://service.region.amazonaws.com")}) input := &InputService26TestShapeInputService26TestCaseOperation2Input{ Name: aws.String("myname"), } req, _ := svc.InputService26TestCaseOperation2Request(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.AssertXML(t, `<MemberRefOpRequest><Name>myname</Name></MemberRefOpRequest>`, 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/path", r.URL.String()) } func TestInputService27ProtocolTestHeaderWhitespaceCase1(t testing.T) { svc := NewInputService27ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) input := &InputService27TestShapeInputService27TestCaseOperation1Input{ Header1: aws.String(" headerValue"), HeaderMap: map[string]string{ " key-leading-space": aws.String("value"), " key-with-space ": aws.String("value"), "leading-space": aws.String(" value"), "leading-tab": aws.String(" value"), "with-space": aws.String(" value "), }, } req, _ := svc.InputService27TestCaseOperation1Request(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()) // assert headers if e, a := "value", r.Header.Get("header-map-key-leading-space"); e != a { t.Errorf("expect header-map-key-leading-space %v header value, got %v", e, a) } if e, a := "value", r.Header.Get("header-map-key-with-space"); e != a { t.Errorf("expect header-map-key-with-space %v header value, got %v", e, a) } if e, a := "value", r.Header.Get("header-map-leading-space"); e != a { t.Errorf("expect header-map-leading-space %v header value, got %v", e, a) } if e, a := "value", r.Header.Get("header-map-leading-tab"); e != a { t.Errorf("expect header-map-leading-tab %v header value, got %v", e, a) } if e, a := "value", r.Header.Get("header-map-with-space"); e != a { t.Errorf("expect header-map-with-space %v header value, got %v", e, a) } if e, a := "headerValue", r.Header.Get("header1"); e != a { t.Errorf("expect header1 %v header value, got %v", e, a) } }	303.85 KB	2025-05-25 12:27
📄 restxml.go // Package restxml provides RESTful XML serialization of AWS // requests and responses. package restxml //go:generate go run -tags codegen ../../../private/model/cli/gen-protocol-tests ../../../models/protocol_tests/input/rest-xml.json build_test.go //go:generate go run -tags codegen ../../../private/model/cli/gen-protocol-tests ../../../models/protocol_tests/output/rest-xml.json unmarshal_test.go import ( "bytes" "encoding/xml" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/request" "github.com/aws/aws-sdk-go/private/protocol/query" "github.com/aws/aws-sdk-go/private/protocol/rest" "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil" ) // BuildHandler is a named request handler for building restxml protocol requests var BuildHandler = request.NamedHandler{Name: "awssdk.restxml.Build", Fn: Build} // UnmarshalHandler is a named request handler for unmarshaling restxml protocol requests var UnmarshalHandler = request.NamedHandler{Name: "awssdk.restxml.Unmarshal", Fn: Unmarshal} // UnmarshalMetaHandler is a named request handler for unmarshaling restxml protocol request metadata var UnmarshalMetaHandler = request.NamedHandler{Name: "awssdk.restxml.UnmarshalMeta", Fn: UnmarshalMeta} // UnmarshalErrorHandler is a named request handler for unmarshaling restxml protocol request errors var UnmarshalErrorHandler = request.NamedHandler{Name: "awssdk.restxml.UnmarshalError", Fn: UnmarshalError} // Build builds a request payload for the REST XML protocol. func Build(r request.Request) { rest.Build(r) if t := rest.PayloadType(r.Params); t == "structure" \|\| t == "" { var buf bytes.Buffer err := xmlutil.BuildXML(r.Params, xml.NewEncoder(&buf)) if err != nil { r.Error = awserr.NewRequestFailure( awserr.New(request.ErrCodeSerialization, "failed to encode rest XML request", err), 0, r.RequestID, ) return } r.SetBufferBody(buf.Bytes()) } } // Unmarshal unmarshals a payload response for the REST XML protocol. func Unmarshal(r request.Request) { if t := rest.PayloadType(r.Data); t == "structure" \|\| t == "" { defer r.HTTPResponse.Body.Close() decoder := xml.NewDecoder(r.HTTPResponse.Body) err := xmlutil.UnmarshalXML(r.Data, decoder, "") if err != nil { r.Error = awserr.NewRequestFailure( awserr.New(request.ErrCodeSerialization, "failed to decode REST XML response", err), r.HTTPResponse.StatusCode, r.RequestID, ) return } } else { rest.Unmarshal(r) } } // UnmarshalMeta unmarshals response headers for the REST XML protocol. func UnmarshalMeta(r request.Request) { rest.UnmarshalMeta(r) } // UnmarshalError unmarshals a response error for the REST XML protocol. func UnmarshalError(r request.Request) { query.UnmarshalError(r) }	2.71 KB	2025-05-25 12:27
📄 unmarshal_test.go // Code generated by models/protocol_tests/generate.go. DO NOT EDIT. package restxml_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/restxml" "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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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() } const opOutputService1TestCaseOperation2 = "OperationName" // OutputService1TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the OutputService1TestCaseOperation2 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 OutputService1TestCaseOperation2 for more information on using the OutputService1TestCaseOperation2 // 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 OutputService1TestCaseOperation2Request method. // req, resp := client.OutputService1TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService1ProtocolTest) OutputService1TestCaseOperation2Request(input OutputService1TestShapeOutputService1TestCaseOperation2Input) (req request.Request, output OutputService1TestShapeOutputService1TestCaseOperation2Output) { op := &request.Operation{ Name: opOutputService1TestCaseOperation2, HTTPPath: "/", } if input == nil { input = &OutputService1TestShapeOutputService1TestCaseOperation2Input{} } output = &OutputService1TestShapeOutputService1TestCaseOperation2Output{} req = c.newRequest(op, input, output) return } // OutputService1TestCaseOperation2 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 OutputService1TestCaseOperation2 for usage and error information. func (c OutputService1ProtocolTest) OutputService1TestCaseOperation2(input OutputService1TestShapeOutputService1TestCaseOperation2Input) (OutputService1TestShapeOutputService1TestCaseOperation2Output, error) { req, out := c.OutputService1TestCaseOperation2Request(input) return out, req.Send() } // OutputService1TestCaseOperation2WithContext is the same as OutputService1TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See OutputService1TestCaseOperation2 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) OutputService1TestCaseOperation2WithContext(ctx aws.Context, input OutputService1TestShapeOutputService1TestCaseOperation2Input, opts ...request.Option) (OutputService1TestShapeOutputService1TestCaseOperation2Output, error) { req, out := c.OutputService1TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService1TestShapeOutputService1TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService1TestShapeOutputService1TestCaseOperation1Output struct { _ struct{} `type:"structure"` // Blob is automatically base64 encoded/decoded by the SDK. Blob []byte `type:"blob"` // BlobHeader is automatically base64 encoded/decoded by the SDK. BlobHeader []byte `location:"header" type:"blob"` Char string `type:"character"` Double float64 `type:"double"` FalseBool bool `type:"boolean"` Float float64 `type:"float"` ImaHeader string `location:"header" type:"string"` ImaHeaderLocation string `location:"header" locationName:"X-Foo" type:"string"` Long int64 `type:"long"` Num int64 `locationName:"FooNum" type:"integer"` Str string `type:"string"` Timestamp time.Time `type:"timestamp"` TrueBool bool `type:"boolean"` } // SetBlob sets the Blob field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation1Output) SetBlob(v []byte) OutputService1TestShapeOutputService1TestCaseOperation1Output { s.Blob = v return s } // SetBlobHeader sets the BlobHeader field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation1Output) SetBlobHeader(v []byte) OutputService1TestShapeOutputService1TestCaseOperation1Output { s.BlobHeader = v return s } // 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 } // SetImaHeader sets the ImaHeader field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation1Output) SetImaHeader(v string) OutputService1TestShapeOutputService1TestCaseOperation1Output { s.ImaHeader = &v return s } // SetImaHeaderLocation sets the ImaHeaderLocation field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation1Output) SetImaHeaderLocation(v string) OutputService1TestShapeOutputService1TestCaseOperation1Output { s.ImaHeaderLocation = &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 } // SetTimestamp sets the Timestamp field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation1Output) SetTimestamp(v time.Time) OutputService1TestShapeOutputService1TestCaseOperation1Output { s.Timestamp = &v return s } // SetTrueBool sets the TrueBool field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation1Output) SetTrueBool(v bool) OutputService1TestShapeOutputService1TestCaseOperation1Output { s.TrueBool = &v return s } type OutputService1TestShapeOutputService1TestCaseOperation2Input struct { _ struct{} `type:"structure"` } type OutputService1TestShapeOutputService1TestCaseOperation2Output struct { _ struct{} `type:"structure"` // Blob is automatically base64 encoded/decoded by the SDK. Blob []byte `type:"blob"` // BlobHeader is automatically base64 encoded/decoded by the SDK. BlobHeader []byte `location:"header" type:"blob"` Char string `type:"character"` Double float64 `type:"double"` FalseBool bool `type:"boolean"` Float float64 `type:"float"` ImaHeader string `location:"header" type:"string"` ImaHeaderLocation string `location:"header" locationName:"X-Foo" type:"string"` Long int64 `type:"long"` Num int64 `locationName:"FooNum" type:"integer"` Str string `type:"string"` Timestamp time.Time `type:"timestamp"` TrueBool bool `type:"boolean"` } // SetBlob sets the Blob field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation2Output) SetBlob(v []byte) OutputService1TestShapeOutputService1TestCaseOperation2Output { s.Blob = v return s } // SetBlobHeader sets the BlobHeader field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation2Output) SetBlobHeader(v []byte) OutputService1TestShapeOutputService1TestCaseOperation2Output { s.BlobHeader = v return s } // SetChar sets the Char field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation2Output) SetChar(v string) OutputService1TestShapeOutputService1TestCaseOperation2Output { s.Char = &v return s } // SetDouble sets the Double field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation2Output) SetDouble(v float64) OutputService1TestShapeOutputService1TestCaseOperation2Output { s.Double = &v return s } // SetFalseBool sets the FalseBool field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation2Output) SetFalseBool(v bool) OutputService1TestShapeOutputService1TestCaseOperation2Output { s.FalseBool = &v return s } // SetFloat sets the Float field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation2Output) SetFloat(v float64) OutputService1TestShapeOutputService1TestCaseOperation2Output { s.Float = &v return s } // SetImaHeader sets the ImaHeader field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation2Output) SetImaHeader(v string) OutputService1TestShapeOutputService1TestCaseOperation2Output { s.ImaHeader = &v return s } // SetImaHeaderLocation sets the ImaHeaderLocation field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation2Output) SetImaHeaderLocation(v string) OutputService1TestShapeOutputService1TestCaseOperation2Output { s.ImaHeaderLocation = &v return s } // SetLong sets the Long field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation2Output) SetLong(v int64) OutputService1TestShapeOutputService1TestCaseOperation2Output { s.Long = &v return s } // SetNum sets the Num field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation2Output) SetNum(v int64) OutputService1TestShapeOutputService1TestCaseOperation2Output { s.Num = &v return s } // SetStr sets the Str field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation2Output) SetStr(v string) OutputService1TestShapeOutputService1TestCaseOperation2Output { s.Str = &v return s } // SetTimestamp sets the Timestamp field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation2Output) SetTimestamp(v time.Time) OutputService1TestShapeOutputService1TestCaseOperation2Output { s.Timestamp = &v return s } // SetTrueBool sets the TrueBool field's value. func (s OutputService1TestShapeOutputService1TestCaseOperation2Output) SetTrueBool(v bool) OutputService1TestShapeOutputService1TestCaseOperation2Output { 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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 OutputService2TestShapeOutputService2TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService2TestShapeOutputService2TestCaseOperation1Output struct { _ struct{} `type:"structure"` // Blob is automatically base64 encoded/decoded by the SDK. Blob []byte `type:"blob"` } // SetBlob sets the Blob field's value. func (s OutputService2TestShapeOutputService2TestCaseOperation1Output) SetBlob(v []byte) OutputService2TestShapeOutputService2TestCaseOperation1Output { s.Blob = 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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"` ListMember []string `type:"list"` } // SetListMember sets the ListMember field's value. func (s OutputService3TestShapeOutputService3TestCaseOperation1Output) SetListMember(v []string) OutputService3TestShapeOutputService3TestCaseOperation1Output { s.ListMember = 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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() } type OutputService4TestShapeOutputService4TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService4TestShapeOutputService4TestCaseOperation1Output struct { _ struct{} `type:"structure"` ListMember []string `locationNameList:"item" type:"list"` } // SetListMember sets the ListMember field's value. func (s OutputService4TestShapeOutputService4TestCaseOperation1Output) SetListMember(v []string) OutputService4TestShapeOutputService4TestCaseOperation1Output { s.ListMember = v return s } // 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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"` ListMember []string `type:"list" flattened:"true"` } // SetListMember sets the ListMember field's value. func (s OutputService5TestShapeOutputService5TestCaseOperation1Output) SetListMember(v []string) OutputService5TestShapeOutputService5TestCaseOperation1Output { s.ListMember = 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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"` Map map[string]OutputService6TestShapeSingleStructure `type:"map"` } // SetMap sets the Map field's value. func (s OutputService6TestShapeOutputService6TestCaseOperation1Output) SetMap(v map[string]OutputService6TestShapeSingleStructure) OutputService6TestShapeOutputService6TestCaseOperation1Output { s.Map = v return s } type OutputService6TestShapeSingleStructure struct { _ struct{} `type:"structure"` Foo string `locationName:"foo" type:"string"` } // SetFoo sets the Foo field's value. func (s OutputService6TestShapeSingleStructure) SetFoo(v string) OutputService6TestShapeSingleStructure { s.Foo = &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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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"` Map map[string]string `type:"map" flattened:"true"` } // SetMap sets the Map field's value. func (s OutputService7TestShapeOutputService7TestCaseOperation1Output) SetMap(v map[string]string) OutputService7TestShapeOutputService7TestCaseOperation1Output { s.Map = v return s } // 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(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.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) 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() } type OutputService8TestShapeOutputService8TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService8TestShapeOutputService8TestCaseOperation1Output struct { _ struct{} `type:"structure"` Map map[string]string `locationNameKey:"foo" locationNameValue:"bar" type:"map"` } // SetMap sets the Map field's value. func (s OutputService8TestShapeOutputService8TestCaseOperation1Output) SetMap(v map[string]string) OutputService8TestShapeOutputService8TestCaseOperation1Output { s.Map = v return s } // OutputService9ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService9ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService9ProtocolTest struct { client.Client } // New creates a new instance of the OutputService9ProtocolTest 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 OutputService9ProtocolTest client from just a session. // svc := outputservice9protocoltest.New(mySession) // // // Create a OutputService9ProtocolTest client with additional configuration // svc := outputservice9protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService9ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService9ProtocolTest { c := p.ClientConfig("outputservice9protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService9ProtocolTestClient(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 newOutputService9ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService9ProtocolTest { svc := &OutputService9ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService9ProtocolTest", ServiceID: "OutputService9ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService9ProtocolTest operation and runs any // custom request initialization. func (c OutputService9ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService9TestCaseOperation1 = "OperationName" // OutputService9TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService9TestCaseOperation1 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 OutputService9TestCaseOperation1 for more information on using the OutputService9TestCaseOperation1 // 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 OutputService9TestCaseOperation1Request method. // req, resp := client.OutputService9TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService9ProtocolTest) OutputService9TestCaseOperation1Request(input OutputService9TestShapeOutputService9TestCaseOperation1Input) (req request.Request, output OutputService9TestShapeOutputService9TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService9TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &OutputService9TestShapeOutputService9TestCaseOperation1Input{} } output = &OutputService9TestShapeOutputService9TestCaseOperation1Output{} req = c.newRequest(op, input, output) return } // OutputService9TestCaseOperation1 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 OutputService9TestCaseOperation1 for usage and error information. func (c OutputService9ProtocolTest) OutputService9TestCaseOperation1(input OutputService9TestShapeOutputService9TestCaseOperation1Input) (OutputService9TestShapeOutputService9TestCaseOperation1Output, error) { req, out := c.OutputService9TestCaseOperation1Request(input) return out, req.Send() } // OutputService9TestCaseOperation1WithContext is the same as OutputService9TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService9TestCaseOperation1 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 OutputService9ProtocolTest) OutputService9TestCaseOperation1WithContext(ctx aws.Context, input OutputService9TestShapeOutputService9TestCaseOperation1Input, opts ...request.Option) (OutputService9TestShapeOutputService9TestCaseOperation1Output, error) { req, out := c.OutputService9TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService9TestShapeOutputService9TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService9TestShapeOutputService9TestCaseOperation1Output struct { _ struct{} `type:"structure" payload:"Data"` Data OutputService9TestShapeSingleStructure `type:"structure"` Header string `location:"header" locationName:"X-Foo" type:"string"` } // SetData sets the Data field's value. func (s OutputService9TestShapeOutputService9TestCaseOperation1Output) SetData(v OutputService9TestShapeSingleStructure) OutputService9TestShapeOutputService9TestCaseOperation1Output { s.Data = v return s } // SetHeader sets the Header field's value. func (s OutputService9TestShapeOutputService9TestCaseOperation1Output) SetHeader(v string) OutputService9TestShapeOutputService9TestCaseOperation1Output { s.Header = &v return s } type OutputService9TestShapeSingleStructure struct { _ struct{} `type:"structure"` Foo string `type:"string"` } // SetFoo sets the Foo field's value. func (s OutputService9TestShapeSingleStructure) SetFoo(v string) OutputService9TestShapeSingleStructure { s.Foo = &v return s } // OutputService10ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService10ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService10ProtocolTest struct { client.Client } // New creates a new instance of the OutputService10ProtocolTest 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 OutputService10ProtocolTest client from just a session. // svc := outputservice10protocoltest.New(mySession) // // // Create a OutputService10ProtocolTest client with additional configuration // svc := outputservice10protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService10ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService10ProtocolTest { c := p.ClientConfig("outputservice10protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService10ProtocolTestClient(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 newOutputService10ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService10ProtocolTest { svc := &OutputService10ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService10ProtocolTest", ServiceID: "OutputService10ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService10ProtocolTest operation and runs any // custom request initialization. func (c OutputService10ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService10TestCaseOperation1 = "OperationName" // OutputService10TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService10TestCaseOperation1 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 OutputService10TestCaseOperation1 for more information on using the OutputService10TestCaseOperation1 // 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 OutputService10TestCaseOperation1Request method. // req, resp := client.OutputService10TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService10ProtocolTest) OutputService10TestCaseOperation1Request(input OutputService10TestShapeOutputService10TestCaseOperation1Input) (req request.Request, output OutputService10TestShapeOutputService10TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService10TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &OutputService10TestShapeOutputService10TestCaseOperation1Input{} } output = &OutputService10TestShapeOutputService10TestCaseOperation1Output{} req = c.newRequest(op, input, output) return } // OutputService10TestCaseOperation1 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 OutputService10TestCaseOperation1 for usage and error information. func (c OutputService10ProtocolTest) OutputService10TestCaseOperation1(input OutputService10TestShapeOutputService10TestCaseOperation1Input) (OutputService10TestShapeOutputService10TestCaseOperation1Output, error) { req, out := c.OutputService10TestCaseOperation1Request(input) return out, req.Send() } // OutputService10TestCaseOperation1WithContext is the same as OutputService10TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService10TestCaseOperation1 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 OutputService10ProtocolTest) OutputService10TestCaseOperation1WithContext(ctx aws.Context, input OutputService10TestShapeOutputService10TestCaseOperation1Input, opts ...request.Option) (OutputService10TestShapeOutputService10TestCaseOperation1Output, error) { req, out := c.OutputService10TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService10TestShapeOutputService10TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService10TestShapeOutputService10TestCaseOperation1Output struct { _ struct{} `type:"structure" payload:"Stream"` Stream []byte `type:"blob"` } // SetStream sets the Stream field's value. func (s OutputService10TestShapeOutputService10TestCaseOperation1Output) SetStream(v []byte) OutputService10TestShapeOutputService10TestCaseOperation1Output { s.Stream = v return s } // OutputService11ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService11ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService11ProtocolTest struct { client.Client } // New creates a new instance of the OutputService11ProtocolTest 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 OutputService11ProtocolTest client from just a session. // svc := outputservice11protocoltest.New(mySession) // // // Create a OutputService11ProtocolTest client with additional configuration // svc := outputservice11protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService11ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService11ProtocolTest { c := p.ClientConfig("outputservice11protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService11ProtocolTestClient(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 newOutputService11ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService11ProtocolTest { svc := &OutputService11ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService11ProtocolTest", ServiceID: "OutputService11ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService11ProtocolTest operation and runs any // custom request initialization. func (c OutputService11ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService11TestCaseOperation1 = "OperationName" // OutputService11TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService11TestCaseOperation1 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 OutputService11TestCaseOperation1 for more information on using the OutputService11TestCaseOperation1 // 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 OutputService11TestCaseOperation1Request method. // req, resp := client.OutputService11TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService11ProtocolTest) OutputService11TestCaseOperation1Request(input OutputService11TestShapeOutputService11TestCaseOperation1Input) (req request.Request, output OutputService11TestShapeOutputService11TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService11TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &OutputService11TestShapeOutputService11TestCaseOperation1Input{} } output = &OutputService11TestShapeOutputService11TestCaseOperation1Output{} req = c.newRequest(op, input, output) return } // OutputService11TestCaseOperation1 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 OutputService11TestCaseOperation1 for usage and error information. func (c OutputService11ProtocolTest) OutputService11TestCaseOperation1(input OutputService11TestShapeOutputService11TestCaseOperation1Input) (OutputService11TestShapeOutputService11TestCaseOperation1Output, error) { req, out := c.OutputService11TestCaseOperation1Request(input) return out, req.Send() } // OutputService11TestCaseOperation1WithContext is the same as OutputService11TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService11TestCaseOperation1 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 OutputService11ProtocolTest) OutputService11TestCaseOperation1WithContext(ctx aws.Context, input OutputService11TestShapeOutputService11TestCaseOperation1Input, opts ...request.Option) (OutputService11TestShapeOutputService11TestCaseOperation1Output, error) { req, out := c.OutputService11TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService11TestShapeOutputService11TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService11TestShapeOutputService11TestCaseOperation1Output struct { _ struct{} `type:"structure"` Char string `location:"header" locationName:"x-char" type:"character"` Double float64 `location:"header" locationName:"x-double" type:"double"` FalseBool bool `location:"header" locationName:"x-false-bool" type:"boolean"` Float float64 `location:"header" locationName:"x-float" type:"float"` Integer int64 `location:"header" locationName:"x-int" type:"integer"` Long int64 `location:"header" locationName:"x-long" type:"long"` Str string `location:"header" locationName:"x-str" type:"string"` Timestamp time.Time `location:"header" locationName:"x-timestamp" type:"timestamp"` TrueBool bool `location:"header" locationName:"x-true-bool" type:"boolean"` } // SetChar sets the Char field's value. func (s OutputService11TestShapeOutputService11TestCaseOperation1Output) SetChar(v string) OutputService11TestShapeOutputService11TestCaseOperation1Output { s.Char = &v return s } // SetDouble sets the Double field's value. func (s OutputService11TestShapeOutputService11TestCaseOperation1Output) SetDouble(v float64) OutputService11TestShapeOutputService11TestCaseOperation1Output { s.Double = &v return s } // SetFalseBool sets the FalseBool field's value. func (s OutputService11TestShapeOutputService11TestCaseOperation1Output) SetFalseBool(v bool) OutputService11TestShapeOutputService11TestCaseOperation1Output { s.FalseBool = &v return s } // SetFloat sets the Float field's value. func (s OutputService11TestShapeOutputService11TestCaseOperation1Output) SetFloat(v float64) OutputService11TestShapeOutputService11TestCaseOperation1Output { s.Float = &v return s } // SetInteger sets the Integer field's value. func (s OutputService11TestShapeOutputService11TestCaseOperation1Output) SetInteger(v int64) OutputService11TestShapeOutputService11TestCaseOperation1Output { s.Integer = &v return s } // SetLong sets the Long field's value. func (s OutputService11TestShapeOutputService11TestCaseOperation1Output) SetLong(v int64) OutputService11TestShapeOutputService11TestCaseOperation1Output { s.Long = &v return s } // SetStr sets the Str field's value. func (s OutputService11TestShapeOutputService11TestCaseOperation1Output) SetStr(v string) OutputService11TestShapeOutputService11TestCaseOperation1Output { s.Str = &v return s } // SetTimestamp sets the Timestamp field's value. func (s OutputService11TestShapeOutputService11TestCaseOperation1Output) SetTimestamp(v time.Time) OutputService11TestShapeOutputService11TestCaseOperation1Output { s.Timestamp = &v return s } // SetTrueBool sets the TrueBool field's value. func (s OutputService11TestShapeOutputService11TestCaseOperation1Output) SetTrueBool(v bool) OutputService11TestShapeOutputService11TestCaseOperation1Output { s.TrueBool = &v return s } // OutputService12ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService12ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService12ProtocolTest struct { client.Client } // New creates a new instance of the OutputService12ProtocolTest 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 OutputService12ProtocolTest client from just a session. // svc := outputservice12protocoltest.New(mySession) // // // Create a OutputService12ProtocolTest client with additional configuration // svc := outputservice12protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService12ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService12ProtocolTest { c := p.ClientConfig("outputservice12protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService12ProtocolTestClient(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 newOutputService12ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService12ProtocolTest { svc := &OutputService12ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService12ProtocolTest", ServiceID: "OutputService12ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService12ProtocolTest operation and runs any // custom request initialization. func (c OutputService12ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService12TestCaseOperation1 = "OperationName" // OutputService12TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService12TestCaseOperation1 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 OutputService12TestCaseOperation1 for more information on using the OutputService12TestCaseOperation1 // 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 OutputService12TestCaseOperation1Request method. // req, resp := client.OutputService12TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService12ProtocolTest) OutputService12TestCaseOperation1Request(input OutputService12TestShapeOutputService12TestCaseOperation1Input) (req request.Request, output OutputService12TestShapeOutputService12TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService12TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &OutputService12TestShapeOutputService12TestCaseOperation1Input{} } output = &OutputService12TestShapeOutputService12TestCaseOperation1Output{} req = c.newRequest(op, input, output) return } // OutputService12TestCaseOperation1 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 OutputService12TestCaseOperation1 for usage and error information. func (c OutputService12ProtocolTest) OutputService12TestCaseOperation1(input OutputService12TestShapeOutputService12TestCaseOperation1Input) (OutputService12TestShapeOutputService12TestCaseOperation1Output, error) { req, out := c.OutputService12TestCaseOperation1Request(input) return out, req.Send() } // OutputService12TestCaseOperation1WithContext is the same as OutputService12TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService12TestCaseOperation1 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 OutputService12ProtocolTest) OutputService12TestCaseOperation1WithContext(ctx aws.Context, input OutputService12TestShapeOutputService12TestCaseOperation1Input, opts ...request.Option) (OutputService12TestShapeOutputService12TestCaseOperation1Output, error) { req, out := c.OutputService12TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService12TestShapeOutputService12TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService12TestShapeOutputService12TestCaseOperation1Output struct { _ struct{} `type:"structure"` Foo string `type:"string"` } // SetFoo sets the Foo field's value. func (s OutputService12TestShapeOutputService12TestCaseOperation1Output) SetFoo(v string) OutputService12TestShapeOutputService12TestCaseOperation1Output { s.Foo = &v return s } // OutputService13ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService13ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService13ProtocolTest struct { client.Client } // New creates a new instance of the OutputService13ProtocolTest 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 OutputService13ProtocolTest client from just a session. // svc := outputservice13protocoltest.New(mySession) // // // Create a OutputService13ProtocolTest client with additional configuration // svc := outputservice13protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService13ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService13ProtocolTest { c := p.ClientConfig("outputservice13protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService13ProtocolTestClient(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 newOutputService13ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService13ProtocolTest { svc := &OutputService13ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService13ProtocolTest", ServiceID: "OutputService13ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService13ProtocolTest operation and runs any // custom request initialization. func (c OutputService13ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService13TestCaseOperation1 = "OperationName" // OutputService13TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService13TestCaseOperation1 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 OutputService13TestCaseOperation1 for more information on using the OutputService13TestCaseOperation1 // 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 OutputService13TestCaseOperation1Request method. // req, resp := client.OutputService13TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService13ProtocolTest) OutputService13TestCaseOperation1Request(input OutputService13TestShapeOutputService13TestCaseOperation1Input) (req request.Request, output OutputService13TestShapeOutputService13TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService13TestCaseOperation1, HTTPPath: "/", } if input == nil { input = &OutputService13TestShapeOutputService13TestCaseOperation1Input{} } output = &OutputService13TestShapeOutputService13TestCaseOperation1Output{} req = c.newRequest(op, input, output) return } // OutputService13TestCaseOperation1 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 OutputService13TestCaseOperation1 for usage and error information. func (c OutputService13ProtocolTest) OutputService13TestCaseOperation1(input OutputService13TestShapeOutputService13TestCaseOperation1Input) (OutputService13TestShapeOutputService13TestCaseOperation1Output, error) { req, out := c.OutputService13TestCaseOperation1Request(input) return out, req.Send() } // OutputService13TestCaseOperation1WithContext is the same as OutputService13TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService13TestCaseOperation1 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 OutputService13ProtocolTest) OutputService13TestCaseOperation1WithContext(ctx aws.Context, input OutputService13TestShapeOutputService13TestCaseOperation1Input, opts ...request.Option) (OutputService13TestShapeOutputService13TestCaseOperation1Output, error) { req, out := c.OutputService13TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService13TestShapeOutputService13TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService13TestShapeOutputService13TestCaseOperation1Output struct { _ struct{} `type:"structure"` StructMember OutputService13TestShapeTimeContainer `type:"structure"` TimeArg time.Time `type:"timestamp"` TimeArgInHeader time.Time `location:"header" locationName:"x-amz-timearg" type:"timestamp"` TimeCustom time.Time `type:"timestamp" timestampFormat:"rfc822"` TimeCustomInHeader time.Time `location:"header" locationName:"x-amz-timecustom" type:"timestamp" timestampFormat:"unixTimestamp"` TimeFormat time.Time `type:"timestamp" timestampFormat:"unixTimestamp"` TimeFormatInHeader time.Time `location:"header" locationName:"x-amz-timeformat" type:"timestamp" timestampFormat:"unixTimestamp"` } // SetStructMember sets the StructMember field's value. func (s OutputService13TestShapeOutputService13TestCaseOperation1Output) SetStructMember(v OutputService13TestShapeTimeContainer) OutputService13TestShapeOutputService13TestCaseOperation1Output { s.StructMember = v return s } // SetTimeArg sets the TimeArg field's value. func (s OutputService13TestShapeOutputService13TestCaseOperation1Output) SetTimeArg(v time.Time) OutputService13TestShapeOutputService13TestCaseOperation1Output { s.TimeArg = &v return s } // SetTimeArgInHeader sets the TimeArgInHeader field's value. func (s OutputService13TestShapeOutputService13TestCaseOperation1Output) SetTimeArgInHeader(v time.Time) OutputService13TestShapeOutputService13TestCaseOperation1Output { s.TimeArgInHeader = &v return s } // SetTimeCustom sets the TimeCustom field's value. func (s OutputService13TestShapeOutputService13TestCaseOperation1Output) SetTimeCustom(v time.Time) OutputService13TestShapeOutputService13TestCaseOperation1Output { s.TimeCustom = &v return s } // SetTimeCustomInHeader sets the TimeCustomInHeader field's value. func (s OutputService13TestShapeOutputService13TestCaseOperation1Output) SetTimeCustomInHeader(v time.Time) OutputService13TestShapeOutputService13TestCaseOperation1Output { s.TimeCustomInHeader = &v return s } // SetTimeFormat sets the TimeFormat field's value. func (s OutputService13TestShapeOutputService13TestCaseOperation1Output) SetTimeFormat(v time.Time) OutputService13TestShapeOutputService13TestCaseOperation1Output { s.TimeFormat = &v return s } // SetTimeFormatInHeader sets the TimeFormatInHeader field's value. func (s OutputService13TestShapeOutputService13TestCaseOperation1Output) SetTimeFormatInHeader(v time.Time) OutputService13TestShapeOutputService13TestCaseOperation1Output { s.TimeFormatInHeader = &v return s } type OutputService13TestShapeTimeContainer struct { _ struct{} `type:"structure"` Bar time.Time `locationName:"bar" type:"timestamp" timestampFormat:"unixTimestamp"` Foo time.Time `locationName:"foo" type:"timestamp"` } // SetBar sets the Bar field's value. func (s OutputService13TestShapeTimeContainer) SetBar(v time.Time) OutputService13TestShapeTimeContainer { s.Bar = &v return s } // SetFoo sets the Foo field's value. func (s OutputService13TestShapeTimeContainer) SetFoo(v time.Time) OutputService13TestShapeTimeContainer { s.Foo = &v return s } // OutputService14ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService14ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService14ProtocolTest struct { client.Client } // New creates a new instance of the OutputService14ProtocolTest 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 OutputService14ProtocolTest client from just a session. // svc := outputservice14protocoltest.New(mySession) // // // Create a OutputService14ProtocolTest client with additional configuration // svc := outputservice14protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService14ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService14ProtocolTest { c := p.ClientConfig("outputservice14protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService14ProtocolTestClient(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 newOutputService14ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService14ProtocolTest { svc := &OutputService14ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService14ProtocolTest", ServiceID: "OutputService14ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService14ProtocolTest operation and runs any // custom request initialization. func (c OutputService14ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService14TestCaseOperation1 = "OperationName" // OutputService14TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService14TestCaseOperation1 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 OutputService14TestCaseOperation1 for more information on using the OutputService14TestCaseOperation1 // 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 OutputService14TestCaseOperation1Request method. // req, resp := client.OutputService14TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService14ProtocolTest) OutputService14TestCaseOperation1Request(input OutputService14TestShapeOutputService14TestCaseOperation1Input) (req request.Request, output OutputService14TestShapeOutputService14TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService14TestCaseOperation1, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &OutputService14TestShapeOutputService14TestCaseOperation1Input{} } output = &OutputService14TestShapeOutputService14TestCaseOperation1Output{} req = c.newRequest(op, input, output) return } // OutputService14TestCaseOperation1 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 OutputService14TestCaseOperation1 for usage and error information. func (c OutputService14ProtocolTest) OutputService14TestCaseOperation1(input OutputService14TestShapeOutputService14TestCaseOperation1Input) (OutputService14TestShapeOutputService14TestCaseOperation1Output, error) { req, out := c.OutputService14TestCaseOperation1Request(input) return out, req.Send() } // OutputService14TestCaseOperation1WithContext is the same as OutputService14TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService14TestCaseOperation1 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 OutputService14ProtocolTest) OutputService14TestCaseOperation1WithContext(ctx aws.Context, input OutputService14TestShapeOutputService14TestCaseOperation1Input, opts ...request.Option) (OutputService14TestShapeOutputService14TestCaseOperation1Output, error) { req, out := c.OutputService14TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } const opOutputService14TestCaseOperation2 = "OperationName" // OutputService14TestCaseOperation2Request generates a "aws/request.Request" representing the // client's request for the OutputService14TestCaseOperation2 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 OutputService14TestCaseOperation2 for more information on using the OutputService14TestCaseOperation2 // 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 OutputService14TestCaseOperation2Request method. // req, resp := client.OutputService14TestCaseOperation2Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService14ProtocolTest) OutputService14TestCaseOperation2Request(input OutputService14TestShapeOutputService14TestCaseOperation2Input) (req request.Request, output OutputService14TestShapeOutputService14TestCaseOperation2Output) { op := &request.Operation{ Name: opOutputService14TestCaseOperation2, HTTPMethod: "POST", HTTPPath: "/path", } if input == nil { input = &OutputService14TestShapeOutputService14TestCaseOperation2Input{} } output = &OutputService14TestShapeOutputService14TestCaseOperation2Output{} req = c.newRequest(op, input, output) req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) return } // OutputService14TestCaseOperation2 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 OutputService14TestCaseOperation2 for usage and error information. func (c OutputService14ProtocolTest) OutputService14TestCaseOperation2(input OutputService14TestShapeOutputService14TestCaseOperation2Input) (OutputService14TestShapeOutputService14TestCaseOperation2Output, error) { req, out := c.OutputService14TestCaseOperation2Request(input) return out, req.Send() } // OutputService14TestCaseOperation2WithContext is the same as OutputService14TestCaseOperation2 with the addition of // the ability to pass a context and additional request options. // // See OutputService14TestCaseOperation2 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 OutputService14ProtocolTest) OutputService14TestCaseOperation2WithContext(ctx aws.Context, input OutputService14TestShapeOutputService14TestCaseOperation2Input, opts ...request.Option) (OutputService14TestShapeOutputService14TestCaseOperation2Output, error) { req, out := c.OutputService14TestCaseOperation2Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService14TestShapeOutputService14TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService14TestShapeOutputService14TestCaseOperation1Output struct { _ struct{} `type:"structure"` FooEnum string `type:"string" enum:"OutputService14TestShapeRESTJSONEnumType"` HeaderEnum string `location:"header" locationName:"x-amz-enum" type:"string" enum:"OutputService14TestShapeRESTJSONEnumType"` ListEnums []string `type:"list" enum:"OutputService14TestShapeRESTJSONEnumType"` } // SetFooEnum sets the FooEnum field's value. func (s OutputService14TestShapeOutputService14TestCaseOperation1Output) SetFooEnum(v string) OutputService14TestShapeOutputService14TestCaseOperation1Output { s.FooEnum = &v return s } // SetHeaderEnum sets the HeaderEnum field's value. func (s OutputService14TestShapeOutputService14TestCaseOperation1Output) SetHeaderEnum(v string) OutputService14TestShapeOutputService14TestCaseOperation1Output { s.HeaderEnum = &v return s } // SetListEnums sets the ListEnums field's value. func (s OutputService14TestShapeOutputService14TestCaseOperation1Output) SetListEnums(v []string) OutputService14TestShapeOutputService14TestCaseOperation1Output { s.ListEnums = v return s } type OutputService14TestShapeOutputService14TestCaseOperation2Input struct { _ struct{} `locationName:"OutputShape" type:"structure"` FooEnum string `type:"string" enum:"OutputService14TestShapeRESTJSONEnumType"` HeaderEnum string `location:"header" locationName:"x-amz-enum" type:"string" enum:"OutputService14TestShapeRESTJSONEnumType"` ListEnums []string `type:"list" enum:"OutputService14TestShapeRESTJSONEnumType"` } // SetFooEnum sets the FooEnum field's value. func (s OutputService14TestShapeOutputService14TestCaseOperation2Input) SetFooEnum(v string) OutputService14TestShapeOutputService14TestCaseOperation2Input { s.FooEnum = &v return s } // SetHeaderEnum sets the HeaderEnum field's value. func (s OutputService14TestShapeOutputService14TestCaseOperation2Input) SetHeaderEnum(v string) OutputService14TestShapeOutputService14TestCaseOperation2Input { s.HeaderEnum = &v return s } // SetListEnums sets the ListEnums field's value. func (s OutputService14TestShapeOutputService14TestCaseOperation2Input) SetListEnums(v []string) OutputService14TestShapeOutputService14TestCaseOperation2Input { s.ListEnums = v return s } type OutputService14TestShapeOutputService14TestCaseOperation2Output struct { _ struct{} `type:"structure"` } const ( // RESTJSONEnumTypeFoo is a OutputService14TestShapeRESTJSONEnumType enum value RESTJSONEnumTypeFoo = "foo" // RESTJSONEnumTypeBar is a OutputService14TestShapeRESTJSONEnumType enum value RESTJSONEnumTypeBar = "bar" // RESTJSONEnumType0 is a OutputService14TestShapeRESTJSONEnumType enum value RESTJSONEnumType0 = "0" // RESTJSONEnumType1 is a OutputService14TestShapeRESTJSONEnumType enum value RESTJSONEnumType1 = "1" ) // OutputService14TestShapeRESTJSONEnumType_Values returns all elements of the OutputService14TestShapeRESTJSONEnumType enum func OutputService14TestShapeRESTJSONEnumType_Values() []string { return []string{ RESTJSONEnumTypeFoo, RESTJSONEnumTypeBar, RESTJSONEnumType0, RESTJSONEnumType1, } } // OutputService15ProtocolTest provides the API operation methods for making requests to // . See this package's package overview docs // for details on the service. // // OutputService15ProtocolTest methods are safe to use concurrently. It is not safe to // modify mutate any of the struct's properties though. type OutputService15ProtocolTest struct { client.Client } // New creates a new instance of the OutputService15ProtocolTest 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 OutputService15ProtocolTest client from just a session. // svc := outputservice15protocoltest.New(mySession) // // // Create a OutputService15ProtocolTest client with additional configuration // svc := outputservice15protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) func NewOutputService15ProtocolTest(p client.ConfigProvider, cfgs ...aws.Config) OutputService15ProtocolTest { c := p.ClientConfig("outputservice15protocoltest", cfgs...) if c.SigningNameDerived \|\| len(c.SigningName) == 0 { } return newOutputService15ProtocolTestClient(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 newOutputService15ProtocolTestClient(cfg aws.Config, handlers request.Handlers, partitionID, endpoint, signingRegion, signingName, resolvedRegion string) OutputService15ProtocolTest { svc := &OutputService15ProtocolTest{ Client: client.New( cfg, metadata.ClientInfo{ ServiceName: "OutputService15ProtocolTest", ServiceID: "OutputService15ProtocolTest", SigningName: signingName, SigningRegion: signingRegion, PartitionID: partitionID, Endpoint: endpoint, APIVersion: "", ResolvedRegion: resolvedRegion, }, handlers, ), } // Handlers svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) return svc } // newRequest creates a new request for a OutputService15ProtocolTest operation and runs any // custom request initialization. func (c OutputService15ProtocolTest) newRequest(op request.Operation, params, data interface{}) request.Request { req := c.NewRequest(op, params, data) return req } const opOutputService15TestCaseOperation1 = "OperationName" // OutputService15TestCaseOperation1Request generates a "aws/request.Request" representing the // client's request for the OutputService15TestCaseOperation1 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 OutputService15TestCaseOperation1 for more information on using the OutputService15TestCaseOperation1 // 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 OutputService15TestCaseOperation1Request method. // req, resp := client.OutputService15TestCaseOperation1Request(params) // // err := req.Send() // if err == nil { // resp is now filled // fmt.Println(resp) // } func (c OutputService15ProtocolTest) OutputService15TestCaseOperation1Request(input OutputService15TestShapeOutputService15TestCaseOperation1Input) (req request.Request, output OutputService15TestShapeOutputService15TestCaseOperation1Output) { op := &request.Operation{ Name: opOutputService15TestCaseOperation1, HTTPMethod: "GET", HTTPPath: "/path", } if input == nil { input = &OutputService15TestShapeOutputService15TestCaseOperation1Input{} } output = &OutputService15TestShapeOutputService15TestCaseOperation1Output{} req = c.newRequest(op, input, output) return } // OutputService15TestCaseOperation1 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 OutputService15TestCaseOperation1 for usage and error information. func (c OutputService15ProtocolTest) OutputService15TestCaseOperation1(input OutputService15TestShapeOutputService15TestCaseOperation1Input) (OutputService15TestShapeOutputService15TestCaseOperation1Output, error) { req, out := c.OutputService15TestCaseOperation1Request(input) return out, req.Send() } // OutputService15TestCaseOperation1WithContext is the same as OutputService15TestCaseOperation1 with the addition of // the ability to pass a context and additional request options. // // See OutputService15TestCaseOperation1 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 OutputService15ProtocolTest) OutputService15TestCaseOperation1WithContext(ctx aws.Context, input OutputService15TestShapeOutputService15TestCaseOperation1Input, opts ...request.Option) (OutputService15TestShapeOutputService15TestCaseOperation1Output, error) { req, out := c.OutputService15TestCaseOperation1Request(input) req.SetContext(ctx) req.ApplyOptions(opts...) return out, req.Send() } type OutputService15TestShapeItemDetailShape struct { _ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"` ID string `type:"string"` // Type is a required field Type string `locationName:"xsi:type" type:"string" xmlAttribute:"true" required:"true" enum:"OutputService15TestShapeItemType"` } // SetID sets the ID field's value. func (s OutputService15TestShapeItemDetailShape) SetID(v string) OutputService15TestShapeItemDetailShape { s.ID = &v return s } // SetType sets the Type field's value. func (s OutputService15TestShapeItemDetailShape) SetType(v string) OutputService15TestShapeItemDetailShape { s.Type = &v return s } type OutputService15TestShapeItemShape struct { _ struct{} `type:"structure"` ItemDetail OutputService15TestShapeItemDetailShape `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"` } // SetItemDetail sets the ItemDetail field's value. func (s OutputService15TestShapeItemShape) SetItemDetail(v OutputService15TestShapeItemDetailShape) OutputService15TestShapeItemShape { s.ItemDetail = v return s } type OutputService15TestShapeOutputService15TestCaseOperation1Input struct { _ struct{} `type:"structure"` } type OutputService15TestShapeOutputService15TestCaseOperation1Output struct { _ struct{} `type:"structure"` ListItems []OutputService15TestShapeItemShape `locationName:"ItemsList" locationNameList:"Item" type:"list"` } // SetListItems sets the ListItems field's value. func (s OutputService15TestShapeOutputService15TestCaseOperation1Output) SetListItems(v []OutputService15TestShapeItemShape) OutputService15TestShapeOutputService15TestCaseOperation1Output { s.ListItems = v return s } const ( // ItemTypeType1 is a OutputService15TestShapeItemType enum value ItemTypeType1 = "Type1" // ItemTypeType2 is a OutputService15TestShapeItemType enum value ItemTypeType2 = "Type2" // ItemTypeType3 is a OutputService15TestShapeItemType enum value ItemTypeType3 = "Type3" ) // OutputService15TestShapeItemType_Values returns all elements of the OutputService15TestShapeItemType enum func OutputService15TestShapeItemType_Values() []string { return []string{ ItemTypeType1, ItemTypeType2, ItemTypeType3, } } // // Tests begin here // func TestOutputService1ProtocolTestScalarMembersCase1(t testing.T) { svc := NewOutputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("<OperationNameResponse><Str>myname</Str><FooNum>123</FooNum><FalseBool>false</FalseBool><TrueBool>true</TrueBool><Float>1.2</Float><Double>1.3</Double><Long>200</Long><Char>a</Char><Timestamp>2015-01-25T08:00:00Z</Timestamp><Blob>aGVsbG8=</Blob></OperationNameResponse>")) req, out := svc.OutputService1TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers req.HTTPResponse.Header.Set("BlobHeader", "aGVsbG8=") req.HTTPResponse.Header.Set("ImaHeader", "test") req.HTTPResponse.Header.Set("X-Foo", "abc") // 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 := "hello", string(out.Blob); e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "hello", string(out.BlobHeader); e != a { t.Errorf("expect %v, got %v", e, a) } 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 := "test", out.ImaHeader; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "abc", out.ImaHeaderLocation; 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 := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.UTC().String(); 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 TestOutputService1ProtocolTestScalarMembersCase2(t testing.T) { svc := NewOutputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("<OperationNameResponse><Str></Str><FooNum>123</FooNum><FalseBool>false</FalseBool><TrueBool>true</TrueBool><Float>1.2</Float><Double>1.3</Double><Long>200</Long><Char>a</Char><Timestamp>2015-01-25T08:00:00Z</Timestamp></OperationNameResponse>")) req, out := svc.OutputService1TestCaseOperation2Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers req.HTTPResponse.Header.Set("ImaHeader", "test") req.HTTPResponse.Header.Set("X-Foo", "abc") // unmarshal response 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 := "test", out.ImaHeader; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "abc", out.ImaHeaderLocation; 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 := "", out.Str; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.UTC().String(); 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 TestOutputService2ProtocolTestBlobCase1(t testing.T) { svc := NewOutputService2ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("<OperationNameResult><Blob>dmFsdWU=</Blob></OperationNameResult>")) 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 := "value", string(out.Blob); e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService3ProtocolTestListsCase1(t testing.T) { svc := NewOutputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("<OperationNameResult><ListMember><member>abc</member><member>123</member></ListMember></OperationNameResult>")) 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 := "abc", out.ListMember[0]; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "123", out.ListMember[1]; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService4ProtocolTestListWithCustomMemberNameCase1(t testing.T) { svc := NewOutputService4ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("<OperationNameResult><ListMember><item>abc</item><item>123</item></ListMember></OperationNameResult>")) 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 := "abc", out.ListMember[0]; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "123", out.ListMember[1]; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService5ProtocolTestFlattenedListCase1(t testing.T) { svc := NewOutputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("<OperationNameResult><ListMember>abc</ListMember><ListMember>123</ListMember></OperationNameResult>")) 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 := "abc", out.ListMember[0]; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "123", out.ListMember[1]; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService6ProtocolTestNormalMapCase1(t testing.T) { svc := NewOutputService6ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("<OperationNameResult><Map><entry><key>qux</key><value><foo>bar</foo></value></entry><entry><key>baz</key><value><foo>bam</foo></value></entry></Map></OperationNameResult>")) 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") } if e, a := "bam", out.Map["baz"].Foo; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "bar", out.Map["qux"].Foo; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService7ProtocolTestFlattenedMapCase1(t testing.T) { svc := NewOutputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("<OperationNameResult><Map><key>qux</key><value>bar</value></Map><Map><key>baz</key><value>bam</value></Map></OperationNameResult>")) 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 := "bam", out.Map["baz"]; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "bar", out.Map["qux"]; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService8ProtocolTestNamedMapCase1(t testing.T) { svc := NewOutputService8ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("<OperationNameResult><Map><entry><foo>qux</foo><bar>bar</bar></entry><entry><foo>baz</foo><bar>bam</bar></entry></Map></OperationNameResult>")) 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") } if e, a := "bam", out.Map["baz"]; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "bar", out.Map["qux"]; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService9ProtocolTestXMLPayloadCase1(t testing.T) { svc := NewOutputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("<OperationNameResponse><Foo>abc</Foo></OperationNameResponse>")) req, out := svc.OutputService9TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers req.HTTPResponse.Header.Set("X-Foo", "baz") // unmarshal response 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 := "abc", out.Data.Foo; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "baz", out.Header; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService10ProtocolTestStreamingPayloadCase1(t testing.T) { svc := NewOutputService10ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("abc")) req, out := svc.OutputService10TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers // unmarshal response 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 := "abc", string(out.Stream); e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService11ProtocolTestScalarMembersInHeadersCase1(t testing.T) { svc := NewOutputService11ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("")) req, out := svc.OutputService11TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers req.HTTPResponse.Header.Set("x-char", "a") req.HTTPResponse.Header.Set("x-double", "1.5") req.HTTPResponse.Header.Set("x-false-bool", "false") req.HTTPResponse.Header.Set("x-float", "1.5") req.HTTPResponse.Header.Set("x-int", "1") req.HTTPResponse.Header.Set("x-long", "100") req.HTTPResponse.Header.Set("x-str", "string") req.HTTPResponse.Header.Set("x-timestamp", "Sun, 25 Jan 2015 08:00:00 GMT") req.HTTPResponse.Header.Set("x-true-bool", "true") // unmarshal response 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.5, 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.5, out.Float; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := int64(1), out.Integer; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := int64(100), out.Long; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "string", out.Str; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.UTC().String(); 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 TestOutputService12ProtocolTestEmptyStringCase1(t testing.T) { svc := NewOutputService12ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("<OperationNameResponse><Foo/><RequestId>requestid</RequestId></OperationNameResponse>")) req, out := svc.OutputService12TestCaseOperation1Request(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 := "", out.Foo; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService13ProtocolTestTimestampMembersCase1(t testing.T) { svc := NewOutputService13ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("<OperationNameResponse><StructMember><foo>2014-04-29T18:30:38Z</foo><bar>1398796238</bar></StructMember><TimeArg>2014-04-29T18:30:38Z</TimeArg><TimeCustom>Tue, 29 Apr 2014 18:30:38 GMT</TimeCustom><TimeFormat>1398796238</TimeFormat><RequestId>requestid</RequestId></OperationNameResponse>")) req, out := svc.OutputService13TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers req.HTTPResponse.Header.Set("x-amz-timearg", "Tue, 29 Apr 2014 18:30:38 GMT") req.HTTPResponse.Header.Set("x-amz-timecustom", "1398796238") req.HTTPResponse.Header.Set("x-amz-timeformat", "1398796238") // 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.TimeArgInHeader.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.TimeCustomInHeader.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) } if e, a := time.Unix(1.398796238e+09, 0).UTC().String(), out.TimeFormatInHeader.UTC().String(); e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService14ProtocolTestEnumCase1(t testing.T) { svc := NewOutputService14ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("<OperationNameResponse><FooEnum>foo</FooEnum><ListEnums><member>0</member><member>1</member></ListEnums></OperationNameResponse>")) req, out := svc.OutputService14TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers req.HTTPResponse.Header.Set("x-amz-enum", "baz") // 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 := "baz", out.HeaderEnum; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "0", out.ListEnums[0]; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "1", out.ListEnums[1]; e != a { t.Errorf("expect %v, got %v", e, a) } } func TestOutputService14ProtocolTestEnumCase2(t testing.T) { svc := NewOutputService14ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("")) req, out := svc.OutputService14TestCaseOperation2Request(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 TestOutputService15ProtocolTestXMLAttributesCase1(t testing.T) { svc := NewOutputService15ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) buf := bytes.NewReader([]byte("<SomeOutputDoc xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\"><ItemsList><Item><ItemDetail xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"Type1\"><ID>id1</ID></ItemDetail></Item><Item><ItemDetail xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"Type2\"><ID>id2</ID></ItemDetail></Item><Item><ItemDetail xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"Type3\"><ID>id3</ID></ItemDetail></Item></ItemsList></SomeOutputDoc>")) req, out := svc.OutputService15TestCaseOperation1Request(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 := "id1", out.ListItems[0].ItemDetail.ID; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "Type1", out.ListItems[0].ItemDetail.Type; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "id2", out.ListItems[1].ItemDetail.ID; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "Type2", out.ListItems[1].ItemDetail.Type; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "id3", out.ListItems[2].ItemDetail.ID; e != a { t.Errorf("expect %v, got %v", e, a) } if e, a := "Type3", *out.ListItems[2].ItemDetail.Type; e != a { t.Errorf("expect %v, got %v", e, a) } }	139.8 KB	2025-05-25 12:27

Terminal