1package query_test 2 3import ( 4 "bytes" 5 "encoding/json" 6 "encoding/xml" 7 "fmt" 8 "io" 9 "io/ioutil" 10 "net/http" 11 "net/url" 12 "reflect" 13 "testing" 14 "time" 15 16 "github.com/aws/aws-sdk-go/aws" 17 "github.com/aws/aws-sdk-go/aws/client" 18 "github.com/aws/aws-sdk-go/aws/client/metadata" 19 "github.com/aws/aws-sdk-go/aws/request" 20 "github.com/aws/aws-sdk-go/aws/signer/v4" 21 "github.com/aws/aws-sdk-go/awstesting" 22 "github.com/aws/aws-sdk-go/awstesting/unit" 23 "github.com/aws/aws-sdk-go/private/protocol" 24 "github.com/aws/aws-sdk-go/private/protocol/query" 25 "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil" 26 "github.com/aws/aws-sdk-go/private/util" 27) 28 29var _ bytes.Buffer // always import bytes 30var _ http.Request 31var _ json.Marshaler 32var _ time.Time 33var _ xmlutil.XMLNode 34var _ xml.Attr 35var _ = ioutil.Discard 36var _ = util.Trim("") 37var _ = url.Values{} 38var _ = io.EOF 39var _ = aws.String 40var _ = fmt.Println 41var _ = reflect.Value{} 42 43func init() { 44 protocol.RandReader = &awstesting.ZeroReader{} 45} 46 47// InputService1ProtocolTest provides the API operation methods for making requests to 48// . See this package's package overview docs 49// for details on the service. 50// 51// InputService1ProtocolTest methods are safe to use concurrently. It is not safe to 52// modify mutate any of the struct's properties though. 53type InputService1ProtocolTest struct { 54 *client.Client 55} 56 57// New creates a new instance of the InputService1ProtocolTest client with a session. 58// If additional configuration is needed for the client instance use the optional 59// aws.Config parameter to add your extra config. 60// 61// Example: 62// // Create a InputService1ProtocolTest client from just a session. 63// svc := inputservice1protocoltest.New(mySession) 64// 65// // Create a InputService1ProtocolTest client with additional configuration 66// svc := inputservice1protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 67func NewInputService1ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService1ProtocolTest { 68 c := p.ClientConfig("inputservice1protocoltest", cfgs...) 69 return newInputService1ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 70} 71 72// newClient creates, initializes and returns a new service client instance. 73func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService1ProtocolTest { 74 svc := &InputService1ProtocolTest{ 75 Client: client.New( 76 cfg, 77 metadata.ClientInfo{ 78 ServiceName: "InputService1ProtocolTest", 79 ServiceID: "InputService1ProtocolTest", 80 SigningName: signingName, 81 SigningRegion: signingRegion, 82 Endpoint: endpoint, 83 APIVersion: "2014-01-01", 84 }, 85 handlers, 86 ), 87 } 88 89 // Handlers 90 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 91 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 92 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 93 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 94 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 95 96 return svc 97} 98 99// newRequest creates a new request for a InputService1ProtocolTest operation and runs any 100// custom request initialization. 101func (c *InputService1ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 102 req := c.NewRequest(op, params, data) 103 104 return req 105} 106 107const opInputService1TestCaseOperation1 = "OperationName" 108 109// InputService1TestCaseOperation1Request generates a "aws/request.Request" representing the 110// client's request for the InputService1TestCaseOperation1 operation. The "output" return 111// value will be populated with the request's response once the request completes 112// successfuly. 113// 114// Use "Send" method on the returned Request to send the API call to the service. 115// the "output" return value is not valid until after Send returns without error. 116// 117// See InputService1TestCaseOperation1 for more information on using the InputService1TestCaseOperation1 118// API call, and error handling. 119// 120// This method is useful when you want to inject custom logic or configuration 121// into the SDK's request lifecycle. Such as custom headers, or retry logic. 122// 123// 124// // Example sending a request using the InputService1TestCaseOperation1Request method. 125// req, resp := client.InputService1TestCaseOperation1Request(params) 126// 127// err := req.Send() 128// if err == nil { // resp is now filled 129// fmt.Println(resp) 130// } 131func (c *InputService1ProtocolTest) InputService1TestCaseOperation1Request(input *InputService1TestShapeInputService1TestCaseOperation3Input) (req *request.Request, output *InputService1TestShapeInputService1TestCaseOperation1Output) { 132 op := &request.Operation{ 133 Name: opInputService1TestCaseOperation1, 134 HTTPPath: "/", 135 } 136 137 if input == nil { 138 input = &InputService1TestShapeInputService1TestCaseOperation3Input{} 139 } 140 141 output = &InputService1TestShapeInputService1TestCaseOperation1Output{} 142 req = c.newRequest(op, input, output) 143 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 144 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 145 return 146} 147 148// InputService1TestCaseOperation1 API operation for . 149// 150// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 151// with awserr.Error's Code and Message methods to get detailed information about 152// the error. 153// 154// See the AWS API reference guide for 's 155// API operation InputService1TestCaseOperation1 for usage and error information. 156func (c *InputService1ProtocolTest) InputService1TestCaseOperation1(input *InputService1TestShapeInputService1TestCaseOperation3Input) (*InputService1TestShapeInputService1TestCaseOperation1Output, error) { 157 req, out := c.InputService1TestCaseOperation1Request(input) 158 return out, req.Send() 159} 160 161// InputService1TestCaseOperation1WithContext is the same as InputService1TestCaseOperation1 with the addition of 162// the ability to pass a context and additional request options. 163// 164// See InputService1TestCaseOperation1 for details on how to use this API operation. 165// 166// The context must be non-nil and will be used for request cancellation. If 167// the context is nil a panic will occur. In the future the SDK may create 168// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 169// for more information on using Contexts. 170func (c *InputService1ProtocolTest) InputService1TestCaseOperation1WithContext(ctx aws.Context, input *InputService1TestShapeInputService1TestCaseOperation3Input, opts ...request.Option) (*InputService1TestShapeInputService1TestCaseOperation1Output, error) { 171 req, out := c.InputService1TestCaseOperation1Request(input) 172 req.SetContext(ctx) 173 req.ApplyOptions(opts...) 174 return out, req.Send() 175} 176 177const opInputService1TestCaseOperation2 = "OperationName" 178 179// InputService1TestCaseOperation2Request generates a "aws/request.Request" representing the 180// client's request for the InputService1TestCaseOperation2 operation. The "output" return 181// value will be populated with the request's response once the request completes 182// successfuly. 183// 184// Use "Send" method on the returned Request to send the API call to the service. 185// the "output" return value is not valid until after Send returns without error. 186// 187// See InputService1TestCaseOperation2 for more information on using the InputService1TestCaseOperation2 188// API call, and error handling. 189// 190// This method is useful when you want to inject custom logic or configuration 191// into the SDK's request lifecycle. Such as custom headers, or retry logic. 192// 193// 194// // Example sending a request using the InputService1TestCaseOperation2Request method. 195// req, resp := client.InputService1TestCaseOperation2Request(params) 196// 197// err := req.Send() 198// if err == nil { // resp is now filled 199// fmt.Println(resp) 200// } 201func (c *InputService1ProtocolTest) InputService1TestCaseOperation2Request(input *InputService1TestShapeInputService1TestCaseOperation3Input) (req *request.Request, output *InputService1TestShapeInputService1TestCaseOperation2Output) { 202 op := &request.Operation{ 203 Name: opInputService1TestCaseOperation2, 204 HTTPPath: "/", 205 } 206 207 if input == nil { 208 input = &InputService1TestShapeInputService1TestCaseOperation3Input{} 209 } 210 211 output = &InputService1TestShapeInputService1TestCaseOperation2Output{} 212 req = c.newRequest(op, input, output) 213 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 214 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 215 return 216} 217 218// InputService1TestCaseOperation2 API operation for . 219// 220// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 221// with awserr.Error's Code and Message methods to get detailed information about 222// the error. 223// 224// See the AWS API reference guide for 's 225// API operation InputService1TestCaseOperation2 for usage and error information. 226func (c *InputService1ProtocolTest) InputService1TestCaseOperation2(input *InputService1TestShapeInputService1TestCaseOperation3Input) (*InputService1TestShapeInputService1TestCaseOperation2Output, error) { 227 req, out := c.InputService1TestCaseOperation2Request(input) 228 return out, req.Send() 229} 230 231// InputService1TestCaseOperation2WithContext is the same as InputService1TestCaseOperation2 with the addition of 232// the ability to pass a context and additional request options. 233// 234// See InputService1TestCaseOperation2 for details on how to use this API operation. 235// 236// The context must be non-nil and will be used for request cancellation. If 237// the context is nil a panic will occur. In the future the SDK may create 238// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 239// for more information on using Contexts. 240func (c *InputService1ProtocolTest) InputService1TestCaseOperation2WithContext(ctx aws.Context, input *InputService1TestShapeInputService1TestCaseOperation3Input, opts ...request.Option) (*InputService1TestShapeInputService1TestCaseOperation2Output, error) { 241 req, out := c.InputService1TestCaseOperation2Request(input) 242 req.SetContext(ctx) 243 req.ApplyOptions(opts...) 244 return out, req.Send() 245} 246 247const opInputService1TestCaseOperation3 = "OperationName" 248 249// InputService1TestCaseOperation3Request generates a "aws/request.Request" representing the 250// client's request for the InputService1TestCaseOperation3 operation. The "output" return 251// value will be populated with the request's response once the request completes 252// successfuly. 253// 254// Use "Send" method on the returned Request to send the API call to the service. 255// the "output" return value is not valid until after Send returns without error. 256// 257// See InputService1TestCaseOperation3 for more information on using the InputService1TestCaseOperation3 258// API call, and error handling. 259// 260// This method is useful when you want to inject custom logic or configuration 261// into the SDK's request lifecycle. Such as custom headers, or retry logic. 262// 263// 264// // Example sending a request using the InputService1TestCaseOperation3Request method. 265// req, resp := client.InputService1TestCaseOperation3Request(params) 266// 267// err := req.Send() 268// if err == nil { // resp is now filled 269// fmt.Println(resp) 270// } 271func (c *InputService1ProtocolTest) InputService1TestCaseOperation3Request(input *InputService1TestShapeInputService1TestCaseOperation3Input) (req *request.Request, output *InputService1TestShapeInputService1TestCaseOperation3Output) { 272 op := &request.Operation{ 273 Name: opInputService1TestCaseOperation3, 274 HTTPPath: "/", 275 } 276 277 if input == nil { 278 input = &InputService1TestShapeInputService1TestCaseOperation3Input{} 279 } 280 281 output = &InputService1TestShapeInputService1TestCaseOperation3Output{} 282 req = c.newRequest(op, input, output) 283 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 284 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 285 return 286} 287 288// InputService1TestCaseOperation3 API operation for . 289// 290// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 291// with awserr.Error's Code and Message methods to get detailed information about 292// the error. 293// 294// See the AWS API reference guide for 's 295// API operation InputService1TestCaseOperation3 for usage and error information. 296func (c *InputService1ProtocolTest) InputService1TestCaseOperation3(input *InputService1TestShapeInputService1TestCaseOperation3Input) (*InputService1TestShapeInputService1TestCaseOperation3Output, error) { 297 req, out := c.InputService1TestCaseOperation3Request(input) 298 return out, req.Send() 299} 300 301// InputService1TestCaseOperation3WithContext is the same as InputService1TestCaseOperation3 with the addition of 302// the ability to pass a context and additional request options. 303// 304// See InputService1TestCaseOperation3 for details on how to use this API operation. 305// 306// The context must be non-nil and will be used for request cancellation. If 307// the context is nil a panic will occur. In the future the SDK may create 308// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 309// for more information on using Contexts. 310func (c *InputService1ProtocolTest) InputService1TestCaseOperation3WithContext(ctx aws.Context, input *InputService1TestShapeInputService1TestCaseOperation3Input, opts ...request.Option) (*InputService1TestShapeInputService1TestCaseOperation3Output, error) { 311 req, out := c.InputService1TestCaseOperation3Request(input) 312 req.SetContext(ctx) 313 req.ApplyOptions(opts...) 314 return out, req.Send() 315} 316 317type InputService1TestShapeInputService1TestCaseOperation1Output struct { 318 _ struct{} `type:"structure"` 319} 320 321type InputService1TestShapeInputService1TestCaseOperation2Output struct { 322 _ struct{} `type:"structure"` 323} 324 325type InputService1TestShapeInputService1TestCaseOperation3Input struct { 326 _ struct{} `type:"structure"` 327 328 Bar *string `type:"string"` 329 330 Baz *bool `type:"boolean"` 331 332 Foo *string `type:"string"` 333} 334 335// SetBar sets the Bar field's value. 336func (s *InputService1TestShapeInputService1TestCaseOperation3Input) SetBar(v string) *InputService1TestShapeInputService1TestCaseOperation3Input { 337 s.Bar = &v 338 return s 339} 340 341// SetBaz sets the Baz field's value. 342func (s *InputService1TestShapeInputService1TestCaseOperation3Input) SetBaz(v bool) *InputService1TestShapeInputService1TestCaseOperation3Input { 343 s.Baz = &v 344 return s 345} 346 347// SetFoo sets the Foo field's value. 348func (s *InputService1TestShapeInputService1TestCaseOperation3Input) SetFoo(v string) *InputService1TestShapeInputService1TestCaseOperation3Input { 349 s.Foo = &v 350 return s 351} 352 353type InputService1TestShapeInputService1TestCaseOperation3Output struct { 354 _ struct{} `type:"structure"` 355} 356 357// InputService2ProtocolTest provides the API operation methods for making requests to 358// . See this package's package overview docs 359// for details on the service. 360// 361// InputService2ProtocolTest methods are safe to use concurrently. It is not safe to 362// modify mutate any of the struct's properties though. 363type InputService2ProtocolTest struct { 364 *client.Client 365} 366 367// New creates a new instance of the InputService2ProtocolTest client with a session. 368// If additional configuration is needed for the client instance use the optional 369// aws.Config parameter to add your extra config. 370// 371// Example: 372// // Create a InputService2ProtocolTest client from just a session. 373// svc := inputservice2protocoltest.New(mySession) 374// 375// // Create a InputService2ProtocolTest client with additional configuration 376// svc := inputservice2protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 377func NewInputService2ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService2ProtocolTest { 378 c := p.ClientConfig("inputservice2protocoltest", cfgs...) 379 return newInputService2ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 380} 381 382// newClient creates, initializes and returns a new service client instance. 383func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService2ProtocolTest { 384 svc := &InputService2ProtocolTest{ 385 Client: client.New( 386 cfg, 387 metadata.ClientInfo{ 388 ServiceName: "InputService2ProtocolTest", 389 ServiceID: "InputService2ProtocolTest", 390 SigningName: signingName, 391 SigningRegion: signingRegion, 392 Endpoint: endpoint, 393 APIVersion: "2014-01-01", 394 }, 395 handlers, 396 ), 397 } 398 399 // Handlers 400 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 401 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 402 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 403 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 404 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 405 406 return svc 407} 408 409// newRequest creates a new request for a InputService2ProtocolTest operation and runs any 410// custom request initialization. 411func (c *InputService2ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 412 req := c.NewRequest(op, params, data) 413 414 return req 415} 416 417const opInputService2TestCaseOperation1 = "OperationName" 418 419// InputService2TestCaseOperation1Request generates a "aws/request.Request" representing the 420// client's request for the InputService2TestCaseOperation1 operation. The "output" return 421// value will be populated with the request's response once the request completes 422// successfuly. 423// 424// Use "Send" method on the returned Request to send the API call to the service. 425// the "output" return value is not valid until after Send returns without error. 426// 427// See InputService2TestCaseOperation1 for more information on using the InputService2TestCaseOperation1 428// API call, and error handling. 429// 430// This method is useful when you want to inject custom logic or configuration 431// into the SDK's request lifecycle. Such as custom headers, or retry logic. 432// 433// 434// // Example sending a request using the InputService2TestCaseOperation1Request method. 435// req, resp := client.InputService2TestCaseOperation1Request(params) 436// 437// err := req.Send() 438// if err == nil { // resp is now filled 439// fmt.Println(resp) 440// } 441func (c *InputService2ProtocolTest) InputService2TestCaseOperation1Request(input *InputService2TestShapeInputService2TestCaseOperation1Input) (req *request.Request, output *InputService2TestShapeInputService2TestCaseOperation1Output) { 442 op := &request.Operation{ 443 Name: opInputService2TestCaseOperation1, 444 HTTPPath: "/", 445 } 446 447 if input == nil { 448 input = &InputService2TestShapeInputService2TestCaseOperation1Input{} 449 } 450 451 output = &InputService2TestShapeInputService2TestCaseOperation1Output{} 452 req = c.newRequest(op, input, output) 453 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 454 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 455 return 456} 457 458// InputService2TestCaseOperation1 API operation for . 459// 460// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 461// with awserr.Error's Code and Message methods to get detailed information about 462// the error. 463// 464// See the AWS API reference guide for 's 465// API operation InputService2TestCaseOperation1 for usage and error information. 466func (c *InputService2ProtocolTest) InputService2TestCaseOperation1(input *InputService2TestShapeInputService2TestCaseOperation1Input) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) { 467 req, out := c.InputService2TestCaseOperation1Request(input) 468 return out, req.Send() 469} 470 471// InputService2TestCaseOperation1WithContext is the same as InputService2TestCaseOperation1 with the addition of 472// the ability to pass a context and additional request options. 473// 474// See InputService2TestCaseOperation1 for details on how to use this API operation. 475// 476// The context must be non-nil and will be used for request cancellation. If 477// the context is nil a panic will occur. In the future the SDK may create 478// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 479// for more information on using Contexts. 480func (c *InputService2ProtocolTest) InputService2TestCaseOperation1WithContext(ctx aws.Context, input *InputService2TestShapeInputService2TestCaseOperation1Input, opts ...request.Option) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) { 481 req, out := c.InputService2TestCaseOperation1Request(input) 482 req.SetContext(ctx) 483 req.ApplyOptions(opts...) 484 return out, req.Send() 485} 486 487type InputService2TestShapeInputService2TestCaseOperation1Input struct { 488 _ struct{} `type:"structure"` 489 490 StructArg *InputService2TestShapeStructType `type:"structure"` 491} 492 493// SetStructArg sets the StructArg field's value. 494func (s *InputService2TestShapeInputService2TestCaseOperation1Input) SetStructArg(v *InputService2TestShapeStructType) *InputService2TestShapeInputService2TestCaseOperation1Input { 495 s.StructArg = v 496 return s 497} 498 499type InputService2TestShapeInputService2TestCaseOperation1Output struct { 500 _ struct{} `type:"structure"` 501} 502 503type InputService2TestShapeStructType struct { 504 _ struct{} `type:"structure"` 505 506 ScalarArg *string `type:"string"` 507} 508 509// SetScalarArg sets the ScalarArg field's value. 510func (s *InputService2TestShapeStructType) SetScalarArg(v string) *InputService2TestShapeStructType { 511 s.ScalarArg = &v 512 return s 513} 514 515// InputService3ProtocolTest provides the API operation methods for making requests to 516// . See this package's package overview docs 517// for details on the service. 518// 519// InputService3ProtocolTest methods are safe to use concurrently. It is not safe to 520// modify mutate any of the struct's properties though. 521type InputService3ProtocolTest struct { 522 *client.Client 523} 524 525// New creates a new instance of the InputService3ProtocolTest client with a session. 526// If additional configuration is needed for the client instance use the optional 527// aws.Config parameter to add your extra config. 528// 529// Example: 530// // Create a InputService3ProtocolTest client from just a session. 531// svc := inputservice3protocoltest.New(mySession) 532// 533// // Create a InputService3ProtocolTest client with additional configuration 534// svc := inputservice3protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 535func NewInputService3ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService3ProtocolTest { 536 c := p.ClientConfig("inputservice3protocoltest", cfgs...) 537 return newInputService3ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 538} 539 540// newClient creates, initializes and returns a new service client instance. 541func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService3ProtocolTest { 542 svc := &InputService3ProtocolTest{ 543 Client: client.New( 544 cfg, 545 metadata.ClientInfo{ 546 ServiceName: "InputService3ProtocolTest", 547 ServiceID: "InputService3ProtocolTest", 548 SigningName: signingName, 549 SigningRegion: signingRegion, 550 Endpoint: endpoint, 551 APIVersion: "2014-01-01", 552 }, 553 handlers, 554 ), 555 } 556 557 // Handlers 558 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 559 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 560 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 561 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 562 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 563 564 return svc 565} 566 567// newRequest creates a new request for a InputService3ProtocolTest operation and runs any 568// custom request initialization. 569func (c *InputService3ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 570 req := c.NewRequest(op, params, data) 571 572 return req 573} 574 575const opInputService3TestCaseOperation1 = "OperationName" 576 577// InputService3TestCaseOperation1Request generates a "aws/request.Request" representing the 578// client's request for the InputService3TestCaseOperation1 operation. The "output" return 579// value will be populated with the request's response once the request completes 580// successfuly. 581// 582// Use "Send" method on the returned Request to send the API call to the service. 583// the "output" return value is not valid until after Send returns without error. 584// 585// See InputService3TestCaseOperation1 for more information on using the InputService3TestCaseOperation1 586// API call, and error handling. 587// 588// This method is useful when you want to inject custom logic or configuration 589// into the SDK's request lifecycle. Such as custom headers, or retry logic. 590// 591// 592// // Example sending a request using the InputService3TestCaseOperation1Request method. 593// req, resp := client.InputService3TestCaseOperation1Request(params) 594// 595// err := req.Send() 596// if err == nil { // resp is now filled 597// fmt.Println(resp) 598// } 599func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputService3TestCaseOperation2Input) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) { 600 op := &request.Operation{ 601 Name: opInputService3TestCaseOperation1, 602 HTTPPath: "/", 603 } 604 605 if input == nil { 606 input = &InputService3TestShapeInputService3TestCaseOperation2Input{} 607 } 608 609 output = &InputService3TestShapeInputService3TestCaseOperation1Output{} 610 req = c.newRequest(op, input, output) 611 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 612 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 613 return 614} 615 616// InputService3TestCaseOperation1 API operation for . 617// 618// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 619// with awserr.Error's Code and Message methods to get detailed information about 620// the error. 621// 622// See the AWS API reference guide for 's 623// API operation InputService3TestCaseOperation1 for usage and error information. 624func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputService3TestCaseOperation2Input) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) { 625 req, out := c.InputService3TestCaseOperation1Request(input) 626 return out, req.Send() 627} 628 629// InputService3TestCaseOperation1WithContext is the same as InputService3TestCaseOperation1 with the addition of 630// the ability to pass a context and additional request options. 631// 632// See InputService3TestCaseOperation1 for details on how to use this API operation. 633// 634// The context must be non-nil and will be used for request cancellation. If 635// the context is nil a panic will occur. In the future the SDK may create 636// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 637// for more information on using Contexts. 638func (c *InputService3ProtocolTest) InputService3TestCaseOperation1WithContext(ctx aws.Context, input *InputService3TestShapeInputService3TestCaseOperation2Input, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) { 639 req, out := c.InputService3TestCaseOperation1Request(input) 640 req.SetContext(ctx) 641 req.ApplyOptions(opts...) 642 return out, req.Send() 643} 644 645const opInputService3TestCaseOperation2 = "OperationName" 646 647// InputService3TestCaseOperation2Request generates a "aws/request.Request" representing the 648// client's request for the InputService3TestCaseOperation2 operation. The "output" return 649// value will be populated with the request's response once the request completes 650// successfuly. 651// 652// Use "Send" method on the returned Request to send the API call to the service. 653// the "output" return value is not valid until after Send returns without error. 654// 655// See InputService3TestCaseOperation2 for more information on using the InputService3TestCaseOperation2 656// API call, and error handling. 657// 658// This method is useful when you want to inject custom logic or configuration 659// into the SDK's request lifecycle. Such as custom headers, or retry logic. 660// 661// 662// // Example sending a request using the InputService3TestCaseOperation2Request method. 663// req, resp := client.InputService3TestCaseOperation2Request(params) 664// 665// err := req.Send() 666// if err == nil { // resp is now filled 667// fmt.Println(resp) 668// } 669func (c *InputService3ProtocolTest) InputService3TestCaseOperation2Request(input *InputService3TestShapeInputService3TestCaseOperation2Input) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation2Output) { 670 op := &request.Operation{ 671 Name: opInputService3TestCaseOperation2, 672 HTTPPath: "/", 673 } 674 675 if input == nil { 676 input = &InputService3TestShapeInputService3TestCaseOperation2Input{} 677 } 678 679 output = &InputService3TestShapeInputService3TestCaseOperation2Output{} 680 req = c.newRequest(op, input, output) 681 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 682 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 683 return 684} 685 686// InputService3TestCaseOperation2 API operation for . 687// 688// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 689// with awserr.Error's Code and Message methods to get detailed information about 690// the error. 691// 692// See the AWS API reference guide for 's 693// API operation InputService3TestCaseOperation2 for usage and error information. 694func (c *InputService3ProtocolTest) InputService3TestCaseOperation2(input *InputService3TestShapeInputService3TestCaseOperation2Input) (*InputService3TestShapeInputService3TestCaseOperation2Output, error) { 695 req, out := c.InputService3TestCaseOperation2Request(input) 696 return out, req.Send() 697} 698 699// InputService3TestCaseOperation2WithContext is the same as InputService3TestCaseOperation2 with the addition of 700// the ability to pass a context and additional request options. 701// 702// See InputService3TestCaseOperation2 for details on how to use this API operation. 703// 704// The context must be non-nil and will be used for request cancellation. If 705// the context is nil a panic will occur. In the future the SDK may create 706// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 707// for more information on using Contexts. 708func (c *InputService3ProtocolTest) InputService3TestCaseOperation2WithContext(ctx aws.Context, input *InputService3TestShapeInputService3TestCaseOperation2Input, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation2Output, error) { 709 req, out := c.InputService3TestCaseOperation2Request(input) 710 req.SetContext(ctx) 711 req.ApplyOptions(opts...) 712 return out, req.Send() 713} 714 715type InputService3TestShapeInputService3TestCaseOperation1Output struct { 716 _ struct{} `type:"structure"` 717} 718 719type InputService3TestShapeInputService3TestCaseOperation2Input struct { 720 _ struct{} `type:"structure"` 721 722 ListArg []*string `type:"list"` 723} 724 725// SetListArg sets the ListArg field's value. 726func (s *InputService3TestShapeInputService3TestCaseOperation2Input) SetListArg(v []*string) *InputService3TestShapeInputService3TestCaseOperation2Input { 727 s.ListArg = v 728 return s 729} 730 731type InputService3TestShapeInputService3TestCaseOperation2Output struct { 732 _ struct{} `type:"structure"` 733} 734 735// InputService4ProtocolTest provides the API operation methods for making requests to 736// . See this package's package overview docs 737// for details on the service. 738// 739// InputService4ProtocolTest methods are safe to use concurrently. It is not safe to 740// modify mutate any of the struct's properties though. 741type InputService4ProtocolTest struct { 742 *client.Client 743} 744 745// New creates a new instance of the InputService4ProtocolTest client with a session. 746// If additional configuration is needed for the client instance use the optional 747// aws.Config parameter to add your extra config. 748// 749// Example: 750// // Create a InputService4ProtocolTest client from just a session. 751// svc := inputservice4protocoltest.New(mySession) 752// 753// // Create a InputService4ProtocolTest client with additional configuration 754// svc := inputservice4protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 755func NewInputService4ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService4ProtocolTest { 756 c := p.ClientConfig("inputservice4protocoltest", cfgs...) 757 return newInputService4ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 758} 759 760// newClient creates, initializes and returns a new service client instance. 761func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService4ProtocolTest { 762 svc := &InputService4ProtocolTest{ 763 Client: client.New( 764 cfg, 765 metadata.ClientInfo{ 766 ServiceName: "InputService4ProtocolTest", 767 ServiceID: "InputService4ProtocolTest", 768 SigningName: signingName, 769 SigningRegion: signingRegion, 770 Endpoint: endpoint, 771 APIVersion: "2014-01-01", 772 }, 773 handlers, 774 ), 775 } 776 777 // Handlers 778 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 779 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 780 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 781 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 782 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 783 784 return svc 785} 786 787// newRequest creates a new request for a InputService4ProtocolTest operation and runs any 788// custom request initialization. 789func (c *InputService4ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 790 req := c.NewRequest(op, params, data) 791 792 return req 793} 794 795const opInputService4TestCaseOperation1 = "OperationName" 796 797// InputService4TestCaseOperation1Request generates a "aws/request.Request" representing the 798// client's request for the InputService4TestCaseOperation1 operation. The "output" return 799// value will be populated with the request's response once the request completes 800// successfuly. 801// 802// Use "Send" method on the returned Request to send the API call to the service. 803// the "output" return value is not valid until after Send returns without error. 804// 805// See InputService4TestCaseOperation1 for more information on using the InputService4TestCaseOperation1 806// API call, and error handling. 807// 808// This method is useful when you want to inject custom logic or configuration 809// into the SDK's request lifecycle. Such as custom headers, or retry logic. 810// 811// 812// // Example sending a request using the InputService4TestCaseOperation1Request method. 813// req, resp := client.InputService4TestCaseOperation1Request(params) 814// 815// err := req.Send() 816// if err == nil { // resp is now filled 817// fmt.Println(resp) 818// } 819func (c *InputService4ProtocolTest) InputService4TestCaseOperation1Request(input *InputService4TestShapeInputService4TestCaseOperation2Input) (req *request.Request, output *InputService4TestShapeInputService4TestCaseOperation1Output) { 820 op := &request.Operation{ 821 Name: opInputService4TestCaseOperation1, 822 HTTPPath: "/", 823 } 824 825 if input == nil { 826 input = &InputService4TestShapeInputService4TestCaseOperation2Input{} 827 } 828 829 output = &InputService4TestShapeInputService4TestCaseOperation1Output{} 830 req = c.newRequest(op, input, output) 831 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 832 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 833 return 834} 835 836// InputService4TestCaseOperation1 API operation for . 837// 838// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 839// with awserr.Error's Code and Message methods to get detailed information about 840// the error. 841// 842// See the AWS API reference guide for 's 843// API operation InputService4TestCaseOperation1 for usage and error information. 844func (c *InputService4ProtocolTest) InputService4TestCaseOperation1(input *InputService4TestShapeInputService4TestCaseOperation2Input) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) { 845 req, out := c.InputService4TestCaseOperation1Request(input) 846 return out, req.Send() 847} 848 849// InputService4TestCaseOperation1WithContext is the same as InputService4TestCaseOperation1 with the addition of 850// the ability to pass a context and additional request options. 851// 852// See InputService4TestCaseOperation1 for details on how to use this API operation. 853// 854// The context must be non-nil and will be used for request cancellation. If 855// the context is nil a panic will occur. In the future the SDK may create 856// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 857// for more information on using Contexts. 858func (c *InputService4ProtocolTest) InputService4TestCaseOperation1WithContext(ctx aws.Context, input *InputService4TestShapeInputService4TestCaseOperation2Input, opts ...request.Option) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) { 859 req, out := c.InputService4TestCaseOperation1Request(input) 860 req.SetContext(ctx) 861 req.ApplyOptions(opts...) 862 return out, req.Send() 863} 864 865const opInputService4TestCaseOperation2 = "OperationName" 866 867// InputService4TestCaseOperation2Request generates a "aws/request.Request" representing the 868// client's request for the InputService4TestCaseOperation2 operation. The "output" return 869// value will be populated with the request's response once the request completes 870// successfuly. 871// 872// Use "Send" method on the returned Request to send the API call to the service. 873// the "output" return value is not valid until after Send returns without error. 874// 875// See InputService4TestCaseOperation2 for more information on using the InputService4TestCaseOperation2 876// API call, and error handling. 877// 878// This method is useful when you want to inject custom logic or configuration 879// into the SDK's request lifecycle. Such as custom headers, or retry logic. 880// 881// 882// // Example sending a request using the InputService4TestCaseOperation2Request method. 883// req, resp := client.InputService4TestCaseOperation2Request(params) 884// 885// err := req.Send() 886// if err == nil { // resp is now filled 887// fmt.Println(resp) 888// } 889func (c *InputService4ProtocolTest) InputService4TestCaseOperation2Request(input *InputService4TestShapeInputService4TestCaseOperation2Input) (req *request.Request, output *InputService4TestShapeInputService4TestCaseOperation2Output) { 890 op := &request.Operation{ 891 Name: opInputService4TestCaseOperation2, 892 HTTPPath: "/", 893 } 894 895 if input == nil { 896 input = &InputService4TestShapeInputService4TestCaseOperation2Input{} 897 } 898 899 output = &InputService4TestShapeInputService4TestCaseOperation2Output{} 900 req = c.newRequest(op, input, output) 901 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 902 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 903 return 904} 905 906// InputService4TestCaseOperation2 API operation for . 907// 908// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 909// with awserr.Error's Code and Message methods to get detailed information about 910// the error. 911// 912// See the AWS API reference guide for 's 913// API operation InputService4TestCaseOperation2 for usage and error information. 914func (c *InputService4ProtocolTest) InputService4TestCaseOperation2(input *InputService4TestShapeInputService4TestCaseOperation2Input) (*InputService4TestShapeInputService4TestCaseOperation2Output, error) { 915 req, out := c.InputService4TestCaseOperation2Request(input) 916 return out, req.Send() 917} 918 919// InputService4TestCaseOperation2WithContext is the same as InputService4TestCaseOperation2 with the addition of 920// the ability to pass a context and additional request options. 921// 922// See InputService4TestCaseOperation2 for details on how to use this API operation. 923// 924// The context must be non-nil and will be used for request cancellation. If 925// the context is nil a panic will occur. In the future the SDK may create 926// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 927// for more information on using Contexts. 928func (c *InputService4ProtocolTest) InputService4TestCaseOperation2WithContext(ctx aws.Context, input *InputService4TestShapeInputService4TestCaseOperation2Input, opts ...request.Option) (*InputService4TestShapeInputService4TestCaseOperation2Output, error) { 929 req, out := c.InputService4TestCaseOperation2Request(input) 930 req.SetContext(ctx) 931 req.ApplyOptions(opts...) 932 return out, req.Send() 933} 934 935type InputService4TestShapeInputService4TestCaseOperation1Output struct { 936 _ struct{} `type:"structure"` 937} 938 939type InputService4TestShapeInputService4TestCaseOperation2Input struct { 940 _ struct{} `type:"structure"` 941 942 ListArg []*string `type:"list" flattened:"true"` 943 944 NamedListArg []*string `locationNameList:"Foo" type:"list" flattened:"true"` 945 946 ScalarArg *string `type:"string"` 947} 948 949// SetListArg sets the ListArg field's value. 950func (s *InputService4TestShapeInputService4TestCaseOperation2Input) SetListArg(v []*string) *InputService4TestShapeInputService4TestCaseOperation2Input { 951 s.ListArg = v 952 return s 953} 954 955// SetNamedListArg sets the NamedListArg field's value. 956func (s *InputService4TestShapeInputService4TestCaseOperation2Input) SetNamedListArg(v []*string) *InputService4TestShapeInputService4TestCaseOperation2Input { 957 s.NamedListArg = v 958 return s 959} 960 961// SetScalarArg sets the ScalarArg field's value. 962func (s *InputService4TestShapeInputService4TestCaseOperation2Input) SetScalarArg(v string) *InputService4TestShapeInputService4TestCaseOperation2Input { 963 s.ScalarArg = &v 964 return s 965} 966 967type InputService4TestShapeInputService4TestCaseOperation2Output struct { 968 _ struct{} `type:"structure"` 969} 970 971// InputService5ProtocolTest provides the API operation methods for making requests to 972// . See this package's package overview docs 973// for details on the service. 974// 975// InputService5ProtocolTest methods are safe to use concurrently. It is not safe to 976// modify mutate any of the struct's properties though. 977type InputService5ProtocolTest struct { 978 *client.Client 979} 980 981// New creates a new instance of the InputService5ProtocolTest client with a session. 982// If additional configuration is needed for the client instance use the optional 983// aws.Config parameter to add your extra config. 984// 985// Example: 986// // Create a InputService5ProtocolTest client from just a session. 987// svc := inputservice5protocoltest.New(mySession) 988// 989// // Create a InputService5ProtocolTest client with additional configuration 990// svc := inputservice5protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 991func NewInputService5ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService5ProtocolTest { 992 c := p.ClientConfig("inputservice5protocoltest", cfgs...) 993 return newInputService5ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 994} 995 996// newClient creates, initializes and returns a new service client instance. 997func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService5ProtocolTest { 998 svc := &InputService5ProtocolTest{ 999 Client: client.New( 1000 cfg, 1001 metadata.ClientInfo{ 1002 ServiceName: "InputService5ProtocolTest", 1003 ServiceID: "InputService5ProtocolTest", 1004 SigningName: signingName, 1005 SigningRegion: signingRegion, 1006 Endpoint: endpoint, 1007 APIVersion: "2014-01-01", 1008 }, 1009 handlers, 1010 ), 1011 } 1012 1013 // Handlers 1014 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1015 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 1016 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 1017 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 1018 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 1019 1020 return svc 1021} 1022 1023// newRequest creates a new request for a InputService5ProtocolTest operation and runs any 1024// custom request initialization. 1025func (c *InputService5ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1026 req := c.NewRequest(op, params, data) 1027 1028 return req 1029} 1030 1031const opInputService5TestCaseOperation1 = "OperationName" 1032 1033// InputService5TestCaseOperation1Request generates a "aws/request.Request" representing the 1034// client's request for the InputService5TestCaseOperation1 operation. The "output" return 1035// value will be populated with the request's response once the request completes 1036// successfuly. 1037// 1038// Use "Send" method on the returned Request to send the API call to the service. 1039// the "output" return value is not valid until after Send returns without error. 1040// 1041// See InputService5TestCaseOperation1 for more information on using the InputService5TestCaseOperation1 1042// API call, and error handling. 1043// 1044// This method is useful when you want to inject custom logic or configuration 1045// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1046// 1047// 1048// // Example sending a request using the InputService5TestCaseOperation1Request method. 1049// req, resp := client.InputService5TestCaseOperation1Request(params) 1050// 1051// err := req.Send() 1052// if err == nil { // resp is now filled 1053// fmt.Println(resp) 1054// } 1055func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputService5TestCaseOperation1Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) { 1056 op := &request.Operation{ 1057 Name: opInputService5TestCaseOperation1, 1058 HTTPPath: "/", 1059 } 1060 1061 if input == nil { 1062 input = &InputService5TestShapeInputService5TestCaseOperation1Input{} 1063 } 1064 1065 output = &InputService5TestShapeInputService5TestCaseOperation1Output{} 1066 req = c.newRequest(op, input, output) 1067 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 1068 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1069 return 1070} 1071 1072// InputService5TestCaseOperation1 API operation for . 1073// 1074// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1075// with awserr.Error's Code and Message methods to get detailed information about 1076// the error. 1077// 1078// See the AWS API reference guide for 's 1079// API operation InputService5TestCaseOperation1 for usage and error information. 1080func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputService5TestCaseOperation1Input) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) { 1081 req, out := c.InputService5TestCaseOperation1Request(input) 1082 return out, req.Send() 1083} 1084 1085// InputService5TestCaseOperation1WithContext is the same as InputService5TestCaseOperation1 with the addition of 1086// the ability to pass a context and additional request options. 1087// 1088// See InputService5TestCaseOperation1 for details on how to use this API operation. 1089// 1090// The context must be non-nil and will be used for request cancellation. If 1091// the context is nil a panic will occur. In the future the SDK may create 1092// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1093// for more information on using Contexts. 1094func (c *InputService5ProtocolTest) InputService5TestCaseOperation1WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation1Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) { 1095 req, out := c.InputService5TestCaseOperation1Request(input) 1096 req.SetContext(ctx) 1097 req.ApplyOptions(opts...) 1098 return out, req.Send() 1099} 1100 1101type InputService5TestShapeInputService5TestCaseOperation1Input struct { 1102 _ struct{} `type:"structure"` 1103 1104 MapArg map[string]*string `type:"map" flattened:"true"` 1105} 1106 1107// SetMapArg sets the MapArg field's value. 1108func (s *InputService5TestShapeInputService5TestCaseOperation1Input) SetMapArg(v map[string]*string) *InputService5TestShapeInputService5TestCaseOperation1Input { 1109 s.MapArg = v 1110 return s 1111} 1112 1113type InputService5TestShapeInputService5TestCaseOperation1Output struct { 1114 _ struct{} `type:"structure"` 1115} 1116 1117// InputService6ProtocolTest provides the API operation methods for making requests to 1118// . See this package's package overview docs 1119// for details on the service. 1120// 1121// InputService6ProtocolTest methods are safe to use concurrently. It is not safe to 1122// modify mutate any of the struct's properties though. 1123type InputService6ProtocolTest struct { 1124 *client.Client 1125} 1126 1127// New creates a new instance of the InputService6ProtocolTest client with a session. 1128// If additional configuration is needed for the client instance use the optional 1129// aws.Config parameter to add your extra config. 1130// 1131// Example: 1132// // Create a InputService6ProtocolTest client from just a session. 1133// svc := inputservice6protocoltest.New(mySession) 1134// 1135// // Create a InputService6ProtocolTest client with additional configuration 1136// svc := inputservice6protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1137func NewInputService6ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService6ProtocolTest { 1138 c := p.ClientConfig("inputservice6protocoltest", cfgs...) 1139 return newInputService6ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1140} 1141 1142// newClient creates, initializes and returns a new service client instance. 1143func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService6ProtocolTest { 1144 svc := &InputService6ProtocolTest{ 1145 Client: client.New( 1146 cfg, 1147 metadata.ClientInfo{ 1148 ServiceName: "InputService6ProtocolTest", 1149 ServiceID: "InputService6ProtocolTest", 1150 SigningName: signingName, 1151 SigningRegion: signingRegion, 1152 Endpoint: endpoint, 1153 APIVersion: "2014-01-01", 1154 }, 1155 handlers, 1156 ), 1157 } 1158 1159 // Handlers 1160 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1161 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 1162 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 1163 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 1164 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 1165 1166 return svc 1167} 1168 1169// newRequest creates a new request for a InputService6ProtocolTest operation and runs any 1170// custom request initialization. 1171func (c *InputService6ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1172 req := c.NewRequest(op, params, data) 1173 1174 return req 1175} 1176 1177const opInputService6TestCaseOperation1 = "OperationName" 1178 1179// InputService6TestCaseOperation1Request generates a "aws/request.Request" representing the 1180// client's request for the InputService6TestCaseOperation1 operation. The "output" return 1181// value will be populated with the request's response once the request completes 1182// successfuly. 1183// 1184// Use "Send" method on the returned Request to send the API call to the service. 1185// the "output" return value is not valid until after Send returns without error. 1186// 1187// See InputService6TestCaseOperation1 for more information on using the InputService6TestCaseOperation1 1188// API call, and error handling. 1189// 1190// This method is useful when you want to inject custom logic or configuration 1191// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1192// 1193// 1194// // Example sending a request using the InputService6TestCaseOperation1Request method. 1195// req, resp := client.InputService6TestCaseOperation1Request(params) 1196// 1197// err := req.Send() 1198// if err == nil { // resp is now filled 1199// fmt.Println(resp) 1200// } 1201func (c *InputService6ProtocolTest) InputService6TestCaseOperation1Request(input *InputService6TestShapeInputService6TestCaseOperation1Input) (req *request.Request, output *InputService6TestShapeInputService6TestCaseOperation1Output) { 1202 op := &request.Operation{ 1203 Name: opInputService6TestCaseOperation1, 1204 HTTPPath: "/", 1205 } 1206 1207 if input == nil { 1208 input = &InputService6TestShapeInputService6TestCaseOperation1Input{} 1209 } 1210 1211 output = &InputService6TestShapeInputService6TestCaseOperation1Output{} 1212 req = c.newRequest(op, input, output) 1213 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 1214 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1215 return 1216} 1217 1218// InputService6TestCaseOperation1 API operation for . 1219// 1220// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1221// with awserr.Error's Code and Message methods to get detailed information about 1222// the error. 1223// 1224// See the AWS API reference guide for 's 1225// API operation InputService6TestCaseOperation1 for usage and error information. 1226func (c *InputService6ProtocolTest) InputService6TestCaseOperation1(input *InputService6TestShapeInputService6TestCaseOperation1Input) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) { 1227 req, out := c.InputService6TestCaseOperation1Request(input) 1228 return out, req.Send() 1229} 1230 1231// InputService6TestCaseOperation1WithContext is the same as InputService6TestCaseOperation1 with the addition of 1232// the ability to pass a context and additional request options. 1233// 1234// See InputService6TestCaseOperation1 for details on how to use this API operation. 1235// 1236// The context must be non-nil and will be used for request cancellation. If 1237// the context is nil a panic will occur. In the future the SDK may create 1238// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1239// for more information on using Contexts. 1240func (c *InputService6ProtocolTest) InputService6TestCaseOperation1WithContext(ctx aws.Context, input *InputService6TestShapeInputService6TestCaseOperation1Input, opts ...request.Option) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) { 1241 req, out := c.InputService6TestCaseOperation1Request(input) 1242 req.SetContext(ctx) 1243 req.ApplyOptions(opts...) 1244 return out, req.Send() 1245} 1246 1247type InputService6TestShapeInputService6TestCaseOperation1Input struct { 1248 _ struct{} `type:"structure"` 1249 1250 ListArg []*string `locationNameList:"item" type:"list"` 1251} 1252 1253// SetListArg sets the ListArg field's value. 1254func (s *InputService6TestShapeInputService6TestCaseOperation1Input) SetListArg(v []*string) *InputService6TestShapeInputService6TestCaseOperation1Input { 1255 s.ListArg = v 1256 return s 1257} 1258 1259type InputService6TestShapeInputService6TestCaseOperation1Output struct { 1260 _ struct{} `type:"structure"` 1261} 1262 1263// InputService7ProtocolTest provides the API operation methods for making requests to 1264// . See this package's package overview docs 1265// for details on the service. 1266// 1267// InputService7ProtocolTest methods are safe to use concurrently. It is not safe to 1268// modify mutate any of the struct's properties though. 1269type InputService7ProtocolTest struct { 1270 *client.Client 1271} 1272 1273// New creates a new instance of the InputService7ProtocolTest client with a session. 1274// If additional configuration is needed for the client instance use the optional 1275// aws.Config parameter to add your extra config. 1276// 1277// Example: 1278// // Create a InputService7ProtocolTest client from just a session. 1279// svc := inputservice7protocoltest.New(mySession) 1280// 1281// // Create a InputService7ProtocolTest client with additional configuration 1282// svc := inputservice7protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1283func NewInputService7ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService7ProtocolTest { 1284 c := p.ClientConfig("inputservice7protocoltest", cfgs...) 1285 return newInputService7ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1286} 1287 1288// newClient creates, initializes and returns a new service client instance. 1289func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService7ProtocolTest { 1290 svc := &InputService7ProtocolTest{ 1291 Client: client.New( 1292 cfg, 1293 metadata.ClientInfo{ 1294 ServiceName: "InputService7ProtocolTest", 1295 ServiceID: "InputService7ProtocolTest", 1296 SigningName: signingName, 1297 SigningRegion: signingRegion, 1298 Endpoint: endpoint, 1299 APIVersion: "2014-01-01", 1300 }, 1301 handlers, 1302 ), 1303 } 1304 1305 // Handlers 1306 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1307 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 1308 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 1309 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 1310 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 1311 1312 return svc 1313} 1314 1315// newRequest creates a new request for a InputService7ProtocolTest operation and runs any 1316// custom request initialization. 1317func (c *InputService7ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1318 req := c.NewRequest(op, params, data) 1319 1320 return req 1321} 1322 1323const opInputService7TestCaseOperation1 = "OperationName" 1324 1325// InputService7TestCaseOperation1Request generates a "aws/request.Request" representing the 1326// client's request for the InputService7TestCaseOperation1 operation. The "output" return 1327// value will be populated with the request's response once the request completes 1328// successfuly. 1329// 1330// Use "Send" method on the returned Request to send the API call to the service. 1331// the "output" return value is not valid until after Send returns without error. 1332// 1333// See InputService7TestCaseOperation1 for more information on using the InputService7TestCaseOperation1 1334// API call, and error handling. 1335// 1336// This method is useful when you want to inject custom logic or configuration 1337// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1338// 1339// 1340// // Example sending a request using the InputService7TestCaseOperation1Request method. 1341// req, resp := client.InputService7TestCaseOperation1Request(params) 1342// 1343// err := req.Send() 1344// if err == nil { // resp is now filled 1345// fmt.Println(resp) 1346// } 1347func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputService7TestCaseOperation1Input) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) { 1348 op := &request.Operation{ 1349 Name: opInputService7TestCaseOperation1, 1350 HTTPPath: "/", 1351 } 1352 1353 if input == nil { 1354 input = &InputService7TestShapeInputService7TestCaseOperation1Input{} 1355 } 1356 1357 output = &InputService7TestShapeInputService7TestCaseOperation1Output{} 1358 req = c.newRequest(op, input, output) 1359 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 1360 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1361 return 1362} 1363 1364// InputService7TestCaseOperation1 API operation for . 1365// 1366// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1367// with awserr.Error's Code and Message methods to get detailed information about 1368// the error. 1369// 1370// See the AWS API reference guide for 's 1371// API operation InputService7TestCaseOperation1 for usage and error information. 1372func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputService7TestCaseOperation1Input) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) { 1373 req, out := c.InputService7TestCaseOperation1Request(input) 1374 return out, req.Send() 1375} 1376 1377// InputService7TestCaseOperation1WithContext is the same as InputService7TestCaseOperation1 with the addition of 1378// the ability to pass a context and additional request options. 1379// 1380// See InputService7TestCaseOperation1 for details on how to use this API operation. 1381// 1382// The context must be non-nil and will be used for request cancellation. If 1383// the context is nil a panic will occur. In the future the SDK may create 1384// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1385// for more information on using Contexts. 1386func (c *InputService7ProtocolTest) InputService7TestCaseOperation1WithContext(ctx aws.Context, input *InputService7TestShapeInputService7TestCaseOperation1Input, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) { 1387 req, out := c.InputService7TestCaseOperation1Request(input) 1388 req.SetContext(ctx) 1389 req.ApplyOptions(opts...) 1390 return out, req.Send() 1391} 1392 1393type InputService7TestShapeInputService7TestCaseOperation1Input struct { 1394 _ struct{} `type:"structure"` 1395 1396 ListArg []*string `locationNameList:"ListArgLocation" type:"list" flattened:"true"` 1397 1398 ScalarArg *string `type:"string"` 1399} 1400 1401// SetListArg sets the ListArg field's value. 1402func (s *InputService7TestShapeInputService7TestCaseOperation1Input) SetListArg(v []*string) *InputService7TestShapeInputService7TestCaseOperation1Input { 1403 s.ListArg = v 1404 return s 1405} 1406 1407// SetScalarArg sets the ScalarArg field's value. 1408func (s *InputService7TestShapeInputService7TestCaseOperation1Input) SetScalarArg(v string) *InputService7TestShapeInputService7TestCaseOperation1Input { 1409 s.ScalarArg = &v 1410 return s 1411} 1412 1413type InputService7TestShapeInputService7TestCaseOperation1Output struct { 1414 _ struct{} `type:"structure"` 1415} 1416 1417// InputService8ProtocolTest provides the API operation methods for making requests to 1418// . See this package's package overview docs 1419// for details on the service. 1420// 1421// InputService8ProtocolTest methods are safe to use concurrently. It is not safe to 1422// modify mutate any of the struct's properties though. 1423type InputService8ProtocolTest struct { 1424 *client.Client 1425} 1426 1427// New creates a new instance of the InputService8ProtocolTest client with a session. 1428// If additional configuration is needed for the client instance use the optional 1429// aws.Config parameter to add your extra config. 1430// 1431// Example: 1432// // Create a InputService8ProtocolTest client from just a session. 1433// svc := inputservice8protocoltest.New(mySession) 1434// 1435// // Create a InputService8ProtocolTest client with additional configuration 1436// svc := inputservice8protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1437func NewInputService8ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService8ProtocolTest { 1438 c := p.ClientConfig("inputservice8protocoltest", cfgs...) 1439 return newInputService8ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1440} 1441 1442// newClient creates, initializes and returns a new service client instance. 1443func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService8ProtocolTest { 1444 svc := &InputService8ProtocolTest{ 1445 Client: client.New( 1446 cfg, 1447 metadata.ClientInfo{ 1448 ServiceName: "InputService8ProtocolTest", 1449 ServiceID: "InputService8ProtocolTest", 1450 SigningName: signingName, 1451 SigningRegion: signingRegion, 1452 Endpoint: endpoint, 1453 APIVersion: "2014-01-01", 1454 }, 1455 handlers, 1456 ), 1457 } 1458 1459 // Handlers 1460 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1461 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 1462 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 1463 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 1464 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 1465 1466 return svc 1467} 1468 1469// newRequest creates a new request for a InputService8ProtocolTest operation and runs any 1470// custom request initialization. 1471func (c *InputService8ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1472 req := c.NewRequest(op, params, data) 1473 1474 return req 1475} 1476 1477const opInputService8TestCaseOperation1 = "OperationName" 1478 1479// InputService8TestCaseOperation1Request generates a "aws/request.Request" representing the 1480// client's request for the InputService8TestCaseOperation1 operation. The "output" return 1481// value will be populated with the request's response once the request completes 1482// successfuly. 1483// 1484// Use "Send" method on the returned Request to send the API call to the service. 1485// the "output" return value is not valid until after Send returns without error. 1486// 1487// See InputService8TestCaseOperation1 for more information on using the InputService8TestCaseOperation1 1488// API call, and error handling. 1489// 1490// This method is useful when you want to inject custom logic or configuration 1491// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1492// 1493// 1494// // Example sending a request using the InputService8TestCaseOperation1Request method. 1495// req, resp := client.InputService8TestCaseOperation1Request(params) 1496// 1497// err := req.Send() 1498// if err == nil { // resp is now filled 1499// fmt.Println(resp) 1500// } 1501func (c *InputService8ProtocolTest) InputService8TestCaseOperation1Request(input *InputService8TestShapeInputService8TestCaseOperation1Input) (req *request.Request, output *InputService8TestShapeInputService8TestCaseOperation1Output) { 1502 op := &request.Operation{ 1503 Name: opInputService8TestCaseOperation1, 1504 HTTPPath: "/", 1505 } 1506 1507 if input == nil { 1508 input = &InputService8TestShapeInputService8TestCaseOperation1Input{} 1509 } 1510 1511 output = &InputService8TestShapeInputService8TestCaseOperation1Output{} 1512 req = c.newRequest(op, input, output) 1513 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 1514 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1515 return 1516} 1517 1518// InputService8TestCaseOperation1 API operation for . 1519// 1520// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1521// with awserr.Error's Code and Message methods to get detailed information about 1522// the error. 1523// 1524// See the AWS API reference guide for 's 1525// API operation InputService8TestCaseOperation1 for usage and error information. 1526func (c *InputService8ProtocolTest) InputService8TestCaseOperation1(input *InputService8TestShapeInputService8TestCaseOperation1Input) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) { 1527 req, out := c.InputService8TestCaseOperation1Request(input) 1528 return out, req.Send() 1529} 1530 1531// InputService8TestCaseOperation1WithContext is the same as InputService8TestCaseOperation1 with the addition of 1532// the ability to pass a context and additional request options. 1533// 1534// See InputService8TestCaseOperation1 for details on how to use this API operation. 1535// 1536// The context must be non-nil and will be used for request cancellation. If 1537// the context is nil a panic will occur. In the future the SDK may create 1538// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1539// for more information on using Contexts. 1540func (c *InputService8ProtocolTest) InputService8TestCaseOperation1WithContext(ctx aws.Context, input *InputService8TestShapeInputService8TestCaseOperation1Input, opts ...request.Option) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) { 1541 req, out := c.InputService8TestCaseOperation1Request(input) 1542 req.SetContext(ctx) 1543 req.ApplyOptions(opts...) 1544 return out, req.Send() 1545} 1546 1547type InputService8TestShapeInputService8TestCaseOperation1Input struct { 1548 _ struct{} `type:"structure"` 1549 1550 MapArg map[string]*string `type:"map"` 1551} 1552 1553// SetMapArg sets the MapArg field's value. 1554func (s *InputService8TestShapeInputService8TestCaseOperation1Input) SetMapArg(v map[string]*string) *InputService8TestShapeInputService8TestCaseOperation1Input { 1555 s.MapArg = v 1556 return s 1557} 1558 1559type InputService8TestShapeInputService8TestCaseOperation1Output struct { 1560 _ struct{} `type:"structure"` 1561} 1562 1563// InputService9ProtocolTest provides the API operation methods for making requests to 1564// . See this package's package overview docs 1565// for details on the service. 1566// 1567// InputService9ProtocolTest methods are safe to use concurrently. It is not safe to 1568// modify mutate any of the struct's properties though. 1569type InputService9ProtocolTest struct { 1570 *client.Client 1571} 1572 1573// New creates a new instance of the InputService9ProtocolTest client with a session. 1574// If additional configuration is needed for the client instance use the optional 1575// aws.Config parameter to add your extra config. 1576// 1577// Example: 1578// // Create a InputService9ProtocolTest client from just a session. 1579// svc := inputservice9protocoltest.New(mySession) 1580// 1581// // Create a InputService9ProtocolTest client with additional configuration 1582// svc := inputservice9protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1583func NewInputService9ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService9ProtocolTest { 1584 c := p.ClientConfig("inputservice9protocoltest", cfgs...) 1585 return newInputService9ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1586} 1587 1588// newClient creates, initializes and returns a new service client instance. 1589func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService9ProtocolTest { 1590 svc := &InputService9ProtocolTest{ 1591 Client: client.New( 1592 cfg, 1593 metadata.ClientInfo{ 1594 ServiceName: "InputService9ProtocolTest", 1595 ServiceID: "InputService9ProtocolTest", 1596 SigningName: signingName, 1597 SigningRegion: signingRegion, 1598 Endpoint: endpoint, 1599 APIVersion: "2014-01-01", 1600 }, 1601 handlers, 1602 ), 1603 } 1604 1605 // Handlers 1606 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1607 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 1608 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 1609 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 1610 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 1611 1612 return svc 1613} 1614 1615// newRequest creates a new request for a InputService9ProtocolTest operation and runs any 1616// custom request initialization. 1617func (c *InputService9ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1618 req := c.NewRequest(op, params, data) 1619 1620 return req 1621} 1622 1623const opInputService9TestCaseOperation1 = "OperationName" 1624 1625// InputService9TestCaseOperation1Request generates a "aws/request.Request" representing the 1626// client's request for the InputService9TestCaseOperation1 operation. The "output" return 1627// value will be populated with the request's response once the request completes 1628// successfuly. 1629// 1630// Use "Send" method on the returned Request to send the API call to the service. 1631// the "output" return value is not valid until after Send returns without error. 1632// 1633// See InputService9TestCaseOperation1 for more information on using the InputService9TestCaseOperation1 1634// API call, and error handling. 1635// 1636// This method is useful when you want to inject custom logic or configuration 1637// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1638// 1639// 1640// // Example sending a request using the InputService9TestCaseOperation1Request method. 1641// req, resp := client.InputService9TestCaseOperation1Request(params) 1642// 1643// err := req.Send() 1644// if err == nil { // resp is now filled 1645// fmt.Println(resp) 1646// } 1647func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input *InputService9TestShapeInputService9TestCaseOperation1Input) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation1Output) { 1648 op := &request.Operation{ 1649 Name: opInputService9TestCaseOperation1, 1650 HTTPPath: "/", 1651 } 1652 1653 if input == nil { 1654 input = &InputService9TestShapeInputService9TestCaseOperation1Input{} 1655 } 1656 1657 output = &InputService9TestShapeInputService9TestCaseOperation1Output{} 1658 req = c.newRequest(op, input, output) 1659 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 1660 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1661 return 1662} 1663 1664// InputService9TestCaseOperation1 API operation for . 1665// 1666// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1667// with awserr.Error's Code and Message methods to get detailed information about 1668// the error. 1669// 1670// See the AWS API reference guide for 's 1671// API operation InputService9TestCaseOperation1 for usage and error information. 1672func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *InputService9TestShapeInputService9TestCaseOperation1Input) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) { 1673 req, out := c.InputService9TestCaseOperation1Request(input) 1674 return out, req.Send() 1675} 1676 1677// InputService9TestCaseOperation1WithContext is the same as InputService9TestCaseOperation1 with the addition of 1678// the ability to pass a context and additional request options. 1679// 1680// See InputService9TestCaseOperation1 for details on how to use this API operation. 1681// 1682// The context must be non-nil and will be used for request cancellation. If 1683// the context is nil a panic will occur. In the future the SDK may create 1684// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1685// for more information on using Contexts. 1686func (c *InputService9ProtocolTest) InputService9TestCaseOperation1WithContext(ctx aws.Context, input *InputService9TestShapeInputService9TestCaseOperation1Input, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) { 1687 req, out := c.InputService9TestCaseOperation1Request(input) 1688 req.SetContext(ctx) 1689 req.ApplyOptions(opts...) 1690 return out, req.Send() 1691} 1692 1693type InputService9TestShapeInputService9TestCaseOperation1Input struct { 1694 _ struct{} `type:"structure"` 1695 1696 MapArg map[string]*string `locationNameKey:"TheKey" locationNameValue:"TheValue" type:"map"` 1697} 1698 1699// SetMapArg sets the MapArg field's value. 1700func (s *InputService9TestShapeInputService9TestCaseOperation1Input) SetMapArg(v map[string]*string) *InputService9TestShapeInputService9TestCaseOperation1Input { 1701 s.MapArg = v 1702 return s 1703} 1704 1705type InputService9TestShapeInputService9TestCaseOperation1Output struct { 1706 _ struct{} `type:"structure"` 1707} 1708 1709// InputService10ProtocolTest provides the API operation methods for making requests to 1710// . See this package's package overview docs 1711// for details on the service. 1712// 1713// InputService10ProtocolTest methods are safe to use concurrently. It is not safe to 1714// modify mutate any of the struct's properties though. 1715type InputService10ProtocolTest struct { 1716 *client.Client 1717} 1718 1719// New creates a new instance of the InputService10ProtocolTest client with a session. 1720// If additional configuration is needed for the client instance use the optional 1721// aws.Config parameter to add your extra config. 1722// 1723// Example: 1724// // Create a InputService10ProtocolTest client from just a session. 1725// svc := inputservice10protocoltest.New(mySession) 1726// 1727// // Create a InputService10ProtocolTest client with additional configuration 1728// svc := inputservice10protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1729func NewInputService10ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService10ProtocolTest { 1730 c := p.ClientConfig("inputservice10protocoltest", cfgs...) 1731 return newInputService10ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1732} 1733 1734// newClient creates, initializes and returns a new service client instance. 1735func newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService10ProtocolTest { 1736 svc := &InputService10ProtocolTest{ 1737 Client: client.New( 1738 cfg, 1739 metadata.ClientInfo{ 1740 ServiceName: "InputService10ProtocolTest", 1741 ServiceID: "InputService10ProtocolTest", 1742 SigningName: signingName, 1743 SigningRegion: signingRegion, 1744 Endpoint: endpoint, 1745 APIVersion: "2014-01-01", 1746 }, 1747 handlers, 1748 ), 1749 } 1750 1751 // Handlers 1752 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1753 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 1754 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 1755 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 1756 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 1757 1758 return svc 1759} 1760 1761// newRequest creates a new request for a InputService10ProtocolTest operation and runs any 1762// custom request initialization. 1763func (c *InputService10ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1764 req := c.NewRequest(op, params, data) 1765 1766 return req 1767} 1768 1769const opInputService10TestCaseOperation1 = "OperationName" 1770 1771// InputService10TestCaseOperation1Request generates a "aws/request.Request" representing the 1772// client's request for the InputService10TestCaseOperation1 operation. The "output" return 1773// value will be populated with the request's response once the request completes 1774// successfuly. 1775// 1776// Use "Send" method on the returned Request to send the API call to the service. 1777// the "output" return value is not valid until after Send returns without error. 1778// 1779// See InputService10TestCaseOperation1 for more information on using the InputService10TestCaseOperation1 1780// API call, and error handling. 1781// 1782// This method is useful when you want to inject custom logic or configuration 1783// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1784// 1785// 1786// // Example sending a request using the InputService10TestCaseOperation1Request method. 1787// req, resp := client.InputService10TestCaseOperation1Request(params) 1788// 1789// err := req.Send() 1790// if err == nil { // resp is now filled 1791// fmt.Println(resp) 1792// } 1793func (c *InputService10ProtocolTest) InputService10TestCaseOperation1Request(input *InputService10TestShapeInputService10TestCaseOperation1Input) (req *request.Request, output *InputService10TestShapeInputService10TestCaseOperation1Output) { 1794 op := &request.Operation{ 1795 Name: opInputService10TestCaseOperation1, 1796 HTTPPath: "/", 1797 } 1798 1799 if input == nil { 1800 input = &InputService10TestShapeInputService10TestCaseOperation1Input{} 1801 } 1802 1803 output = &InputService10TestShapeInputService10TestCaseOperation1Output{} 1804 req = c.newRequest(op, input, output) 1805 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 1806 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1807 return 1808} 1809 1810// InputService10TestCaseOperation1 API operation for . 1811// 1812// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1813// with awserr.Error's Code and Message methods to get detailed information about 1814// the error. 1815// 1816// See the AWS API reference guide for 's 1817// API operation InputService10TestCaseOperation1 for usage and error information. 1818func (c *InputService10ProtocolTest) InputService10TestCaseOperation1(input *InputService10TestShapeInputService10TestCaseOperation1Input) (*InputService10TestShapeInputService10TestCaseOperation1Output, error) { 1819 req, out := c.InputService10TestCaseOperation1Request(input) 1820 return out, req.Send() 1821} 1822 1823// InputService10TestCaseOperation1WithContext is the same as InputService10TestCaseOperation1 with the addition of 1824// the ability to pass a context and additional request options. 1825// 1826// See InputService10TestCaseOperation1 for details on how to use this API operation. 1827// 1828// The context must be non-nil and will be used for request cancellation. If 1829// the context is nil a panic will occur. In the future the SDK may create 1830// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1831// for more information on using Contexts. 1832func (c *InputService10ProtocolTest) InputService10TestCaseOperation1WithContext(ctx aws.Context, input *InputService10TestShapeInputService10TestCaseOperation1Input, opts ...request.Option) (*InputService10TestShapeInputService10TestCaseOperation1Output, error) { 1833 req, out := c.InputService10TestCaseOperation1Request(input) 1834 req.SetContext(ctx) 1835 req.ApplyOptions(opts...) 1836 return out, req.Send() 1837} 1838 1839type InputService10TestShapeInputService10TestCaseOperation1Input struct { 1840 _ struct{} `type:"structure"` 1841 1842 // BlobArg is automatically base64 encoded/decoded by the SDK. 1843 BlobArg []byte `type:"blob"` 1844} 1845 1846// SetBlobArg sets the BlobArg field's value. 1847func (s *InputService10TestShapeInputService10TestCaseOperation1Input) SetBlobArg(v []byte) *InputService10TestShapeInputService10TestCaseOperation1Input { 1848 s.BlobArg = v 1849 return s 1850} 1851 1852type InputService10TestShapeInputService10TestCaseOperation1Output struct { 1853 _ struct{} `type:"structure"` 1854} 1855 1856// InputService11ProtocolTest provides the API operation methods for making requests to 1857// . See this package's package overview docs 1858// for details on the service. 1859// 1860// InputService11ProtocolTest methods are safe to use concurrently. It is not safe to 1861// modify mutate any of the struct's properties though. 1862type InputService11ProtocolTest struct { 1863 *client.Client 1864} 1865 1866// New creates a new instance of the InputService11ProtocolTest client with a session. 1867// If additional configuration is needed for the client instance use the optional 1868// aws.Config parameter to add your extra config. 1869// 1870// Example: 1871// // Create a InputService11ProtocolTest client from just a session. 1872// svc := inputservice11protocoltest.New(mySession) 1873// 1874// // Create a InputService11ProtocolTest client with additional configuration 1875// svc := inputservice11protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1876func NewInputService11ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService11ProtocolTest { 1877 c := p.ClientConfig("inputservice11protocoltest", cfgs...) 1878 return newInputService11ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1879} 1880 1881// newClient creates, initializes and returns a new service client instance. 1882func newInputService11ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService11ProtocolTest { 1883 svc := &InputService11ProtocolTest{ 1884 Client: client.New( 1885 cfg, 1886 metadata.ClientInfo{ 1887 ServiceName: "InputService11ProtocolTest", 1888 ServiceID: "InputService11ProtocolTest", 1889 SigningName: signingName, 1890 SigningRegion: signingRegion, 1891 Endpoint: endpoint, 1892 APIVersion: "2014-01-01", 1893 }, 1894 handlers, 1895 ), 1896 } 1897 1898 // Handlers 1899 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1900 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 1901 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 1902 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 1903 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 1904 1905 return svc 1906} 1907 1908// newRequest creates a new request for a InputService11ProtocolTest operation and runs any 1909// custom request initialization. 1910func (c *InputService11ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1911 req := c.NewRequest(op, params, data) 1912 1913 return req 1914} 1915 1916const opInputService11TestCaseOperation1 = "OperationName" 1917 1918// InputService11TestCaseOperation1Request generates a "aws/request.Request" representing the 1919// client's request for the InputService11TestCaseOperation1 operation. The "output" return 1920// value will be populated with the request's response once the request completes 1921// successfuly. 1922// 1923// Use "Send" method on the returned Request to send the API call to the service. 1924// the "output" return value is not valid until after Send returns without error. 1925// 1926// See InputService11TestCaseOperation1 for more information on using the InputService11TestCaseOperation1 1927// API call, and error handling. 1928// 1929// This method is useful when you want to inject custom logic or configuration 1930// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1931// 1932// 1933// // Example sending a request using the InputService11TestCaseOperation1Request method. 1934// req, resp := client.InputService11TestCaseOperation1Request(params) 1935// 1936// err := req.Send() 1937// if err == nil { // resp is now filled 1938// fmt.Println(resp) 1939// } 1940func (c *InputService11ProtocolTest) InputService11TestCaseOperation1Request(input *InputService11TestShapeInputService11TestCaseOperation1Input) (req *request.Request, output *InputService11TestShapeInputService11TestCaseOperation1Output) { 1941 op := &request.Operation{ 1942 Name: opInputService11TestCaseOperation1, 1943 HTTPPath: "/", 1944 } 1945 1946 if input == nil { 1947 input = &InputService11TestShapeInputService11TestCaseOperation1Input{} 1948 } 1949 1950 output = &InputService11TestShapeInputService11TestCaseOperation1Output{} 1951 req = c.newRequest(op, input, output) 1952 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 1953 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1954 return 1955} 1956 1957// InputService11TestCaseOperation1 API operation for . 1958// 1959// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1960// with awserr.Error's Code and Message methods to get detailed information about 1961// the error. 1962// 1963// See the AWS API reference guide for 's 1964// API operation InputService11TestCaseOperation1 for usage and error information. 1965func (c *InputService11ProtocolTest) InputService11TestCaseOperation1(input *InputService11TestShapeInputService11TestCaseOperation1Input) (*InputService11TestShapeInputService11TestCaseOperation1Output, error) { 1966 req, out := c.InputService11TestCaseOperation1Request(input) 1967 return out, req.Send() 1968} 1969 1970// InputService11TestCaseOperation1WithContext is the same as InputService11TestCaseOperation1 with the addition of 1971// the ability to pass a context and additional request options. 1972// 1973// See InputService11TestCaseOperation1 for details on how to use this API operation. 1974// 1975// The context must be non-nil and will be used for request cancellation. If 1976// the context is nil a panic will occur. In the future the SDK may create 1977// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1978// for more information on using Contexts. 1979func (c *InputService11ProtocolTest) InputService11TestCaseOperation1WithContext(ctx aws.Context, input *InputService11TestShapeInputService11TestCaseOperation1Input, opts ...request.Option) (*InputService11TestShapeInputService11TestCaseOperation1Output, error) { 1980 req, out := c.InputService11TestCaseOperation1Request(input) 1981 req.SetContext(ctx) 1982 req.ApplyOptions(opts...) 1983 return out, req.Send() 1984} 1985 1986type InputService11TestShapeInputService11TestCaseOperation1Input struct { 1987 _ struct{} `type:"structure"` 1988 1989 BlobArgs [][]byte `type:"list" flattened:"true"` 1990} 1991 1992// SetBlobArgs sets the BlobArgs field's value. 1993func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetBlobArgs(v [][]byte) *InputService11TestShapeInputService11TestCaseOperation1Input { 1994 s.BlobArgs = v 1995 return s 1996} 1997 1998type InputService11TestShapeInputService11TestCaseOperation1Output struct { 1999 _ struct{} `type:"structure"` 2000} 2001 2002// InputService12ProtocolTest provides the API operation methods for making requests to 2003// . See this package's package overview docs 2004// for details on the service. 2005// 2006// InputService12ProtocolTest methods are safe to use concurrently. It is not safe to 2007// modify mutate any of the struct's properties though. 2008type InputService12ProtocolTest struct { 2009 *client.Client 2010} 2011 2012// New creates a new instance of the InputService12ProtocolTest client with a session. 2013// If additional configuration is needed for the client instance use the optional 2014// aws.Config parameter to add your extra config. 2015// 2016// Example: 2017// // Create a InputService12ProtocolTest client from just a session. 2018// svc := inputservice12protocoltest.New(mySession) 2019// 2020// // Create a InputService12ProtocolTest client with additional configuration 2021// svc := inputservice12protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2022func NewInputService12ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService12ProtocolTest { 2023 c := p.ClientConfig("inputservice12protocoltest", cfgs...) 2024 return newInputService12ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2025} 2026 2027// newClient creates, initializes and returns a new service client instance. 2028func newInputService12ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService12ProtocolTest { 2029 svc := &InputService12ProtocolTest{ 2030 Client: client.New( 2031 cfg, 2032 metadata.ClientInfo{ 2033 ServiceName: "InputService12ProtocolTest", 2034 ServiceID: "InputService12ProtocolTest", 2035 SigningName: signingName, 2036 SigningRegion: signingRegion, 2037 Endpoint: endpoint, 2038 APIVersion: "2014-01-01", 2039 }, 2040 handlers, 2041 ), 2042 } 2043 2044 // Handlers 2045 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2046 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 2047 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 2048 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 2049 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 2050 2051 return svc 2052} 2053 2054// newRequest creates a new request for a InputService12ProtocolTest operation and runs any 2055// custom request initialization. 2056func (c *InputService12ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2057 req := c.NewRequest(op, params, data) 2058 2059 return req 2060} 2061 2062const opInputService12TestCaseOperation1 = "OperationName" 2063 2064// InputService12TestCaseOperation1Request generates a "aws/request.Request" representing the 2065// client's request for the InputService12TestCaseOperation1 operation. The "output" return 2066// value will be populated with the request's response once the request completes 2067// successfuly. 2068// 2069// Use "Send" method on the returned Request to send the API call to the service. 2070// the "output" return value is not valid until after Send returns without error. 2071// 2072// See InputService12TestCaseOperation1 for more information on using the InputService12TestCaseOperation1 2073// API call, and error handling. 2074// 2075// This method is useful when you want to inject custom logic or configuration 2076// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2077// 2078// 2079// // Example sending a request using the InputService12TestCaseOperation1Request method. 2080// req, resp := client.InputService12TestCaseOperation1Request(params) 2081// 2082// err := req.Send() 2083// if err == nil { // resp is now filled 2084// fmt.Println(resp) 2085// } 2086func (c *InputService12ProtocolTest) InputService12TestCaseOperation1Request(input *InputService12TestShapeInputService12TestCaseOperation1Input) (req *request.Request, output *InputService12TestShapeInputService12TestCaseOperation1Output) { 2087 op := &request.Operation{ 2088 Name: opInputService12TestCaseOperation1, 2089 HTTPPath: "/", 2090 } 2091 2092 if input == nil { 2093 input = &InputService12TestShapeInputService12TestCaseOperation1Input{} 2094 } 2095 2096 output = &InputService12TestShapeInputService12TestCaseOperation1Output{} 2097 req = c.newRequest(op, input, output) 2098 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 2099 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2100 return 2101} 2102 2103// InputService12TestCaseOperation1 API operation for . 2104// 2105// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2106// with awserr.Error's Code and Message methods to get detailed information about 2107// the error. 2108// 2109// See the AWS API reference guide for 's 2110// API operation InputService12TestCaseOperation1 for usage and error information. 2111func (c *InputService12ProtocolTest) InputService12TestCaseOperation1(input *InputService12TestShapeInputService12TestCaseOperation1Input) (*InputService12TestShapeInputService12TestCaseOperation1Output, error) { 2112 req, out := c.InputService12TestCaseOperation1Request(input) 2113 return out, req.Send() 2114} 2115 2116// InputService12TestCaseOperation1WithContext is the same as InputService12TestCaseOperation1 with the addition of 2117// the ability to pass a context and additional request options. 2118// 2119// See InputService12TestCaseOperation1 for details on how to use this API operation. 2120// 2121// The context must be non-nil and will be used for request cancellation. If 2122// the context is nil a panic will occur. In the future the SDK may create 2123// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2124// for more information on using Contexts. 2125func (c *InputService12ProtocolTest) InputService12TestCaseOperation1WithContext(ctx aws.Context, input *InputService12TestShapeInputService12TestCaseOperation1Input, opts ...request.Option) (*InputService12TestShapeInputService12TestCaseOperation1Output, error) { 2126 req, out := c.InputService12TestCaseOperation1Request(input) 2127 req.SetContext(ctx) 2128 req.ApplyOptions(opts...) 2129 return out, req.Send() 2130} 2131 2132type InputService12TestShapeInputService12TestCaseOperation1Input struct { 2133 _ struct{} `type:"structure"` 2134 2135 TimeArg *time.Time `type:"timestamp" timestampFormat:"iso8601"` 2136} 2137 2138// SetTimeArg sets the TimeArg field's value. 2139func (s *InputService12TestShapeInputService12TestCaseOperation1Input) SetTimeArg(v time.Time) *InputService12TestShapeInputService12TestCaseOperation1Input { 2140 s.TimeArg = &v 2141 return s 2142} 2143 2144type InputService12TestShapeInputService12TestCaseOperation1Output struct { 2145 _ struct{} `type:"structure"` 2146} 2147 2148// InputService13ProtocolTest provides the API operation methods for making requests to 2149// . See this package's package overview docs 2150// for details on the service. 2151// 2152// InputService13ProtocolTest methods are safe to use concurrently. It is not safe to 2153// modify mutate any of the struct's properties though. 2154type InputService13ProtocolTest struct { 2155 *client.Client 2156} 2157 2158// New creates a new instance of the InputService13ProtocolTest client with a session. 2159// If additional configuration is needed for the client instance use the optional 2160// aws.Config parameter to add your extra config. 2161// 2162// Example: 2163// // Create a InputService13ProtocolTest client from just a session. 2164// svc := inputservice13protocoltest.New(mySession) 2165// 2166// // Create a InputService13ProtocolTest client with additional configuration 2167// svc := inputservice13protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2168func NewInputService13ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService13ProtocolTest { 2169 c := p.ClientConfig("inputservice13protocoltest", cfgs...) 2170 return newInputService13ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2171} 2172 2173// newClient creates, initializes and returns a new service client instance. 2174func newInputService13ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService13ProtocolTest { 2175 svc := &InputService13ProtocolTest{ 2176 Client: client.New( 2177 cfg, 2178 metadata.ClientInfo{ 2179 ServiceName: "InputService13ProtocolTest", 2180 ServiceID: "InputService13ProtocolTest", 2181 SigningName: signingName, 2182 SigningRegion: signingRegion, 2183 Endpoint: endpoint, 2184 APIVersion: "2014-01-01", 2185 }, 2186 handlers, 2187 ), 2188 } 2189 2190 // Handlers 2191 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2192 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 2193 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 2194 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 2195 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 2196 2197 return svc 2198} 2199 2200// newRequest creates a new request for a InputService13ProtocolTest operation and runs any 2201// custom request initialization. 2202func (c *InputService13ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2203 req := c.NewRequest(op, params, data) 2204 2205 return req 2206} 2207 2208const opInputService13TestCaseOperation1 = "OperationName" 2209 2210// InputService13TestCaseOperation1Request generates a "aws/request.Request" representing the 2211// client's request for the InputService13TestCaseOperation1 operation. The "output" return 2212// value will be populated with the request's response once the request completes 2213// successfuly. 2214// 2215// Use "Send" method on the returned Request to send the API call to the service. 2216// the "output" return value is not valid until after Send returns without error. 2217// 2218// See InputService13TestCaseOperation1 for more information on using the InputService13TestCaseOperation1 2219// API call, and error handling. 2220// 2221// This method is useful when you want to inject custom logic or configuration 2222// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2223// 2224// 2225// // Example sending a request using the InputService13TestCaseOperation1Request method. 2226// req, resp := client.InputService13TestCaseOperation1Request(params) 2227// 2228// err := req.Send() 2229// if err == nil { // resp is now filled 2230// fmt.Println(resp) 2231// } 2232func (c *InputService13ProtocolTest) InputService13TestCaseOperation1Request(input *InputService13TestShapeInputService13TestCaseOperation6Input) (req *request.Request, output *InputService13TestShapeInputService13TestCaseOperation1Output) { 2233 op := &request.Operation{ 2234 Name: opInputService13TestCaseOperation1, 2235 HTTPPath: "/", 2236 } 2237 2238 if input == nil { 2239 input = &InputService13TestShapeInputService13TestCaseOperation6Input{} 2240 } 2241 2242 output = &InputService13TestShapeInputService13TestCaseOperation1Output{} 2243 req = c.newRequest(op, input, output) 2244 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 2245 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2246 return 2247} 2248 2249// InputService13TestCaseOperation1 API operation for . 2250// 2251// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2252// with awserr.Error's Code and Message methods to get detailed information about 2253// the error. 2254// 2255// See the AWS API reference guide for 's 2256// API operation InputService13TestCaseOperation1 for usage and error information. 2257func (c *InputService13ProtocolTest) InputService13TestCaseOperation1(input *InputService13TestShapeInputService13TestCaseOperation6Input) (*InputService13TestShapeInputService13TestCaseOperation1Output, error) { 2258 req, out := c.InputService13TestCaseOperation1Request(input) 2259 return out, req.Send() 2260} 2261 2262// InputService13TestCaseOperation1WithContext is the same as InputService13TestCaseOperation1 with the addition of 2263// the ability to pass a context and additional request options. 2264// 2265// See InputService13TestCaseOperation1 for details on how to use this API operation. 2266// 2267// The context must be non-nil and will be used for request cancellation. If 2268// the context is nil a panic will occur. In the future the SDK may create 2269// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2270// for more information on using Contexts. 2271func (c *InputService13ProtocolTest) InputService13TestCaseOperation1WithContext(ctx aws.Context, input *InputService13TestShapeInputService13TestCaseOperation6Input, opts ...request.Option) (*InputService13TestShapeInputService13TestCaseOperation1Output, error) { 2272 req, out := c.InputService13TestCaseOperation1Request(input) 2273 req.SetContext(ctx) 2274 req.ApplyOptions(opts...) 2275 return out, req.Send() 2276} 2277 2278const opInputService13TestCaseOperation2 = "OperationName" 2279 2280// InputService13TestCaseOperation2Request generates a "aws/request.Request" representing the 2281// client's request for the InputService13TestCaseOperation2 operation. The "output" return 2282// value will be populated with the request's response once the request completes 2283// successfuly. 2284// 2285// Use "Send" method on the returned Request to send the API call to the service. 2286// the "output" return value is not valid until after Send returns without error. 2287// 2288// See InputService13TestCaseOperation2 for more information on using the InputService13TestCaseOperation2 2289// API call, and error handling. 2290// 2291// This method is useful when you want to inject custom logic or configuration 2292// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2293// 2294// 2295// // Example sending a request using the InputService13TestCaseOperation2Request method. 2296// req, resp := client.InputService13TestCaseOperation2Request(params) 2297// 2298// err := req.Send() 2299// if err == nil { // resp is now filled 2300// fmt.Println(resp) 2301// } 2302func (c *InputService13ProtocolTest) InputService13TestCaseOperation2Request(input *InputService13TestShapeInputService13TestCaseOperation6Input) (req *request.Request, output *InputService13TestShapeInputService13TestCaseOperation2Output) { 2303 op := &request.Operation{ 2304 Name: opInputService13TestCaseOperation2, 2305 HTTPPath: "/", 2306 } 2307 2308 if input == nil { 2309 input = &InputService13TestShapeInputService13TestCaseOperation6Input{} 2310 } 2311 2312 output = &InputService13TestShapeInputService13TestCaseOperation2Output{} 2313 req = c.newRequest(op, input, output) 2314 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 2315 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2316 return 2317} 2318 2319// InputService13TestCaseOperation2 API operation for . 2320// 2321// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2322// with awserr.Error's Code and Message methods to get detailed information about 2323// the error. 2324// 2325// See the AWS API reference guide for 's 2326// API operation InputService13TestCaseOperation2 for usage and error information. 2327func (c *InputService13ProtocolTest) InputService13TestCaseOperation2(input *InputService13TestShapeInputService13TestCaseOperation6Input) (*InputService13TestShapeInputService13TestCaseOperation2Output, error) { 2328 req, out := c.InputService13TestCaseOperation2Request(input) 2329 return out, req.Send() 2330} 2331 2332// InputService13TestCaseOperation2WithContext is the same as InputService13TestCaseOperation2 with the addition of 2333// the ability to pass a context and additional request options. 2334// 2335// See InputService13TestCaseOperation2 for details on how to use this API operation. 2336// 2337// The context must be non-nil and will be used for request cancellation. If 2338// the context is nil a panic will occur. In the future the SDK may create 2339// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2340// for more information on using Contexts. 2341func (c *InputService13ProtocolTest) InputService13TestCaseOperation2WithContext(ctx aws.Context, input *InputService13TestShapeInputService13TestCaseOperation6Input, opts ...request.Option) (*InputService13TestShapeInputService13TestCaseOperation2Output, error) { 2342 req, out := c.InputService13TestCaseOperation2Request(input) 2343 req.SetContext(ctx) 2344 req.ApplyOptions(opts...) 2345 return out, req.Send() 2346} 2347 2348const opInputService13TestCaseOperation3 = "OperationName" 2349 2350// InputService13TestCaseOperation3Request generates a "aws/request.Request" representing the 2351// client's request for the InputService13TestCaseOperation3 operation. The "output" return 2352// value will be populated with the request's response once the request completes 2353// successfuly. 2354// 2355// Use "Send" method on the returned Request to send the API call to the service. 2356// the "output" return value is not valid until after Send returns without error. 2357// 2358// See InputService13TestCaseOperation3 for more information on using the InputService13TestCaseOperation3 2359// API call, and error handling. 2360// 2361// This method is useful when you want to inject custom logic or configuration 2362// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2363// 2364// 2365// // Example sending a request using the InputService13TestCaseOperation3Request method. 2366// req, resp := client.InputService13TestCaseOperation3Request(params) 2367// 2368// err := req.Send() 2369// if err == nil { // resp is now filled 2370// fmt.Println(resp) 2371// } 2372func (c *InputService13ProtocolTest) InputService13TestCaseOperation3Request(input *InputService13TestShapeInputService13TestCaseOperation6Input) (req *request.Request, output *InputService13TestShapeInputService13TestCaseOperation3Output) { 2373 op := &request.Operation{ 2374 Name: opInputService13TestCaseOperation3, 2375 HTTPPath: "/", 2376 } 2377 2378 if input == nil { 2379 input = &InputService13TestShapeInputService13TestCaseOperation6Input{} 2380 } 2381 2382 output = &InputService13TestShapeInputService13TestCaseOperation3Output{} 2383 req = c.newRequest(op, input, output) 2384 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 2385 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2386 return 2387} 2388 2389// InputService13TestCaseOperation3 API operation for . 2390// 2391// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2392// with awserr.Error's Code and Message methods to get detailed information about 2393// the error. 2394// 2395// See the AWS API reference guide for 's 2396// API operation InputService13TestCaseOperation3 for usage and error information. 2397func (c *InputService13ProtocolTest) InputService13TestCaseOperation3(input *InputService13TestShapeInputService13TestCaseOperation6Input) (*InputService13TestShapeInputService13TestCaseOperation3Output, error) { 2398 req, out := c.InputService13TestCaseOperation3Request(input) 2399 return out, req.Send() 2400} 2401 2402// InputService13TestCaseOperation3WithContext is the same as InputService13TestCaseOperation3 with the addition of 2403// the ability to pass a context and additional request options. 2404// 2405// See InputService13TestCaseOperation3 for details on how to use this API operation. 2406// 2407// The context must be non-nil and will be used for request cancellation. If 2408// the context is nil a panic will occur. In the future the SDK may create 2409// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2410// for more information on using Contexts. 2411func (c *InputService13ProtocolTest) InputService13TestCaseOperation3WithContext(ctx aws.Context, input *InputService13TestShapeInputService13TestCaseOperation6Input, opts ...request.Option) (*InputService13TestShapeInputService13TestCaseOperation3Output, error) { 2412 req, out := c.InputService13TestCaseOperation3Request(input) 2413 req.SetContext(ctx) 2414 req.ApplyOptions(opts...) 2415 return out, req.Send() 2416} 2417 2418const opInputService13TestCaseOperation4 = "OperationName" 2419 2420// InputService13TestCaseOperation4Request generates a "aws/request.Request" representing the 2421// client's request for the InputService13TestCaseOperation4 operation. The "output" return 2422// value will be populated with the request's response once the request completes 2423// successfuly. 2424// 2425// Use "Send" method on the returned Request to send the API call to the service. 2426// the "output" return value is not valid until after Send returns without error. 2427// 2428// See InputService13TestCaseOperation4 for more information on using the InputService13TestCaseOperation4 2429// API call, and error handling. 2430// 2431// This method is useful when you want to inject custom logic or configuration 2432// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2433// 2434// 2435// // Example sending a request using the InputService13TestCaseOperation4Request method. 2436// req, resp := client.InputService13TestCaseOperation4Request(params) 2437// 2438// err := req.Send() 2439// if err == nil { // resp is now filled 2440// fmt.Println(resp) 2441// } 2442func (c *InputService13ProtocolTest) InputService13TestCaseOperation4Request(input *InputService13TestShapeInputService13TestCaseOperation6Input) (req *request.Request, output *InputService13TestShapeInputService13TestCaseOperation4Output) { 2443 op := &request.Operation{ 2444 Name: opInputService13TestCaseOperation4, 2445 HTTPPath: "/", 2446 } 2447 2448 if input == nil { 2449 input = &InputService13TestShapeInputService13TestCaseOperation6Input{} 2450 } 2451 2452 output = &InputService13TestShapeInputService13TestCaseOperation4Output{} 2453 req = c.newRequest(op, input, output) 2454 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 2455 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2456 return 2457} 2458 2459// InputService13TestCaseOperation4 API operation for . 2460// 2461// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2462// with awserr.Error's Code and Message methods to get detailed information about 2463// the error. 2464// 2465// See the AWS API reference guide for 's 2466// API operation InputService13TestCaseOperation4 for usage and error information. 2467func (c *InputService13ProtocolTest) InputService13TestCaseOperation4(input *InputService13TestShapeInputService13TestCaseOperation6Input) (*InputService13TestShapeInputService13TestCaseOperation4Output, error) { 2468 req, out := c.InputService13TestCaseOperation4Request(input) 2469 return out, req.Send() 2470} 2471 2472// InputService13TestCaseOperation4WithContext is the same as InputService13TestCaseOperation4 with the addition of 2473// the ability to pass a context and additional request options. 2474// 2475// See InputService13TestCaseOperation4 for details on how to use this API operation. 2476// 2477// The context must be non-nil and will be used for request cancellation. If 2478// the context is nil a panic will occur. In the future the SDK may create 2479// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2480// for more information on using Contexts. 2481func (c *InputService13ProtocolTest) InputService13TestCaseOperation4WithContext(ctx aws.Context, input *InputService13TestShapeInputService13TestCaseOperation6Input, opts ...request.Option) (*InputService13TestShapeInputService13TestCaseOperation4Output, error) { 2482 req, out := c.InputService13TestCaseOperation4Request(input) 2483 req.SetContext(ctx) 2484 req.ApplyOptions(opts...) 2485 return out, req.Send() 2486} 2487 2488const opInputService13TestCaseOperation5 = "OperationName" 2489 2490// InputService13TestCaseOperation5Request generates a "aws/request.Request" representing the 2491// client's request for the InputService13TestCaseOperation5 operation. The "output" return 2492// value will be populated with the request's response once the request completes 2493// successfuly. 2494// 2495// Use "Send" method on the returned Request to send the API call to the service. 2496// the "output" return value is not valid until after Send returns without error. 2497// 2498// See InputService13TestCaseOperation5 for more information on using the InputService13TestCaseOperation5 2499// API call, and error handling. 2500// 2501// This method is useful when you want to inject custom logic or configuration 2502// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2503// 2504// 2505// // Example sending a request using the InputService13TestCaseOperation5Request method. 2506// req, resp := client.InputService13TestCaseOperation5Request(params) 2507// 2508// err := req.Send() 2509// if err == nil { // resp is now filled 2510// fmt.Println(resp) 2511// } 2512func (c *InputService13ProtocolTest) InputService13TestCaseOperation5Request(input *InputService13TestShapeInputService13TestCaseOperation6Input) (req *request.Request, output *InputService13TestShapeInputService13TestCaseOperation5Output) { 2513 op := &request.Operation{ 2514 Name: opInputService13TestCaseOperation5, 2515 HTTPPath: "/", 2516 } 2517 2518 if input == nil { 2519 input = &InputService13TestShapeInputService13TestCaseOperation6Input{} 2520 } 2521 2522 output = &InputService13TestShapeInputService13TestCaseOperation5Output{} 2523 req = c.newRequest(op, input, output) 2524 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 2525 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2526 return 2527} 2528 2529// InputService13TestCaseOperation5 API operation for . 2530// 2531// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2532// with awserr.Error's Code and Message methods to get detailed information about 2533// the error. 2534// 2535// See the AWS API reference guide for 's 2536// API operation InputService13TestCaseOperation5 for usage and error information. 2537func (c *InputService13ProtocolTest) InputService13TestCaseOperation5(input *InputService13TestShapeInputService13TestCaseOperation6Input) (*InputService13TestShapeInputService13TestCaseOperation5Output, error) { 2538 req, out := c.InputService13TestCaseOperation5Request(input) 2539 return out, req.Send() 2540} 2541 2542// InputService13TestCaseOperation5WithContext is the same as InputService13TestCaseOperation5 with the addition of 2543// the ability to pass a context and additional request options. 2544// 2545// See InputService13TestCaseOperation5 for details on how to use this API operation. 2546// 2547// The context must be non-nil and will be used for request cancellation. If 2548// the context is nil a panic will occur. In the future the SDK may create 2549// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2550// for more information on using Contexts. 2551func (c *InputService13ProtocolTest) InputService13TestCaseOperation5WithContext(ctx aws.Context, input *InputService13TestShapeInputService13TestCaseOperation6Input, opts ...request.Option) (*InputService13TestShapeInputService13TestCaseOperation5Output, error) { 2552 req, out := c.InputService13TestCaseOperation5Request(input) 2553 req.SetContext(ctx) 2554 req.ApplyOptions(opts...) 2555 return out, req.Send() 2556} 2557 2558const opInputService13TestCaseOperation6 = "OperationName" 2559 2560// InputService13TestCaseOperation6Request generates a "aws/request.Request" representing the 2561// client's request for the InputService13TestCaseOperation6 operation. The "output" return 2562// value will be populated with the request's response once the request completes 2563// successfuly. 2564// 2565// Use "Send" method on the returned Request to send the API call to the service. 2566// the "output" return value is not valid until after Send returns without error. 2567// 2568// See InputService13TestCaseOperation6 for more information on using the InputService13TestCaseOperation6 2569// API call, and error handling. 2570// 2571// This method is useful when you want to inject custom logic or configuration 2572// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2573// 2574// 2575// // Example sending a request using the InputService13TestCaseOperation6Request method. 2576// req, resp := client.InputService13TestCaseOperation6Request(params) 2577// 2578// err := req.Send() 2579// if err == nil { // resp is now filled 2580// fmt.Println(resp) 2581// } 2582func (c *InputService13ProtocolTest) InputService13TestCaseOperation6Request(input *InputService13TestShapeInputService13TestCaseOperation6Input) (req *request.Request, output *InputService13TestShapeInputService13TestCaseOperation6Output) { 2583 op := &request.Operation{ 2584 Name: opInputService13TestCaseOperation6, 2585 HTTPPath: "/", 2586 } 2587 2588 if input == nil { 2589 input = &InputService13TestShapeInputService13TestCaseOperation6Input{} 2590 } 2591 2592 output = &InputService13TestShapeInputService13TestCaseOperation6Output{} 2593 req = c.newRequest(op, input, output) 2594 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 2595 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2596 return 2597} 2598 2599// InputService13TestCaseOperation6 API operation for . 2600// 2601// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2602// with awserr.Error's Code and Message methods to get detailed information about 2603// the error. 2604// 2605// See the AWS API reference guide for 's 2606// API operation InputService13TestCaseOperation6 for usage and error information. 2607func (c *InputService13ProtocolTest) InputService13TestCaseOperation6(input *InputService13TestShapeInputService13TestCaseOperation6Input) (*InputService13TestShapeInputService13TestCaseOperation6Output, error) { 2608 req, out := c.InputService13TestCaseOperation6Request(input) 2609 return out, req.Send() 2610} 2611 2612// InputService13TestCaseOperation6WithContext is the same as InputService13TestCaseOperation6 with the addition of 2613// the ability to pass a context and additional request options. 2614// 2615// See InputService13TestCaseOperation6 for details on how to use this API operation. 2616// 2617// The context must be non-nil and will be used for request cancellation. If 2618// the context is nil a panic will occur. In the future the SDK may create 2619// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2620// for more information on using Contexts. 2621func (c *InputService13ProtocolTest) InputService13TestCaseOperation6WithContext(ctx aws.Context, input *InputService13TestShapeInputService13TestCaseOperation6Input, opts ...request.Option) (*InputService13TestShapeInputService13TestCaseOperation6Output, error) { 2622 req, out := c.InputService13TestCaseOperation6Request(input) 2623 req.SetContext(ctx) 2624 req.ApplyOptions(opts...) 2625 return out, req.Send() 2626} 2627 2628type InputService13TestShapeInputService13TestCaseOperation1Output struct { 2629 _ struct{} `type:"structure"` 2630} 2631 2632type InputService13TestShapeInputService13TestCaseOperation2Output struct { 2633 _ struct{} `type:"structure"` 2634} 2635 2636type InputService13TestShapeInputService13TestCaseOperation3Output struct { 2637 _ struct{} `type:"structure"` 2638} 2639 2640type InputService13TestShapeInputService13TestCaseOperation4Output struct { 2641 _ struct{} `type:"structure"` 2642} 2643 2644type InputService13TestShapeInputService13TestCaseOperation5Output struct { 2645 _ struct{} `type:"structure"` 2646} 2647 2648type InputService13TestShapeInputService13TestCaseOperation6Input struct { 2649 _ struct{} `type:"structure"` 2650 2651 RecursiveStruct *InputService13TestShapeRecursiveStructType `type:"structure"` 2652} 2653 2654// SetRecursiveStruct sets the RecursiveStruct field's value. 2655func (s *InputService13TestShapeInputService13TestCaseOperation6Input) SetRecursiveStruct(v *InputService13TestShapeRecursiveStructType) *InputService13TestShapeInputService13TestCaseOperation6Input { 2656 s.RecursiveStruct = v 2657 return s 2658} 2659 2660type InputService13TestShapeInputService13TestCaseOperation6Output struct { 2661 _ struct{} `type:"structure"` 2662} 2663 2664type InputService13TestShapeRecursiveStructType struct { 2665 _ struct{} `type:"structure"` 2666 2667 NoRecurse *string `type:"string"` 2668 2669 RecursiveList []*InputService13TestShapeRecursiveStructType `type:"list"` 2670 2671 RecursiveMap map[string]*InputService13TestShapeRecursiveStructType `type:"map"` 2672 2673 RecursiveStruct *InputService13TestShapeRecursiveStructType `type:"structure"` 2674} 2675 2676// SetNoRecurse sets the NoRecurse field's value. 2677func (s *InputService13TestShapeRecursiveStructType) SetNoRecurse(v string) *InputService13TestShapeRecursiveStructType { 2678 s.NoRecurse = &v 2679 return s 2680} 2681 2682// SetRecursiveList sets the RecursiveList field's value. 2683func (s *InputService13TestShapeRecursiveStructType) SetRecursiveList(v []*InputService13TestShapeRecursiveStructType) *InputService13TestShapeRecursiveStructType { 2684 s.RecursiveList = v 2685 return s 2686} 2687 2688// SetRecursiveMap sets the RecursiveMap field's value. 2689func (s *InputService13TestShapeRecursiveStructType) SetRecursiveMap(v map[string]*InputService13TestShapeRecursiveStructType) *InputService13TestShapeRecursiveStructType { 2690 s.RecursiveMap = v 2691 return s 2692} 2693 2694// SetRecursiveStruct sets the RecursiveStruct field's value. 2695func (s *InputService13TestShapeRecursiveStructType) SetRecursiveStruct(v *InputService13TestShapeRecursiveStructType) *InputService13TestShapeRecursiveStructType { 2696 s.RecursiveStruct = v 2697 return s 2698} 2699 2700// InputService14ProtocolTest provides the API operation methods for making requests to 2701// . See this package's package overview docs 2702// for details on the service. 2703// 2704// InputService14ProtocolTest methods are safe to use concurrently. It is not safe to 2705// modify mutate any of the struct's properties though. 2706type InputService14ProtocolTest struct { 2707 *client.Client 2708} 2709 2710// New creates a new instance of the InputService14ProtocolTest client with a session. 2711// If additional configuration is needed for the client instance use the optional 2712// aws.Config parameter to add your extra config. 2713// 2714// Example: 2715// // Create a InputService14ProtocolTest client from just a session. 2716// svc := inputservice14protocoltest.New(mySession) 2717// 2718// // Create a InputService14ProtocolTest client with additional configuration 2719// svc := inputservice14protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2720func NewInputService14ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService14ProtocolTest { 2721 c := p.ClientConfig("inputservice14protocoltest", cfgs...) 2722 return newInputService14ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2723} 2724 2725// newClient creates, initializes and returns a new service client instance. 2726func newInputService14ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService14ProtocolTest { 2727 svc := &InputService14ProtocolTest{ 2728 Client: client.New( 2729 cfg, 2730 metadata.ClientInfo{ 2731 ServiceName: "InputService14ProtocolTest", 2732 ServiceID: "InputService14ProtocolTest", 2733 SigningName: signingName, 2734 SigningRegion: signingRegion, 2735 Endpoint: endpoint, 2736 APIVersion: "2014-01-01", 2737 }, 2738 handlers, 2739 ), 2740 } 2741 2742 // Handlers 2743 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2744 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 2745 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 2746 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 2747 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 2748 2749 return svc 2750} 2751 2752// newRequest creates a new request for a InputService14ProtocolTest operation and runs any 2753// custom request initialization. 2754func (c *InputService14ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2755 req := c.NewRequest(op, params, data) 2756 2757 return req 2758} 2759 2760const opInputService14TestCaseOperation1 = "OperationName" 2761 2762// InputService14TestCaseOperation1Request generates a "aws/request.Request" representing the 2763// client's request for the InputService14TestCaseOperation1 operation. The "output" return 2764// value will be populated with the request's response once the request completes 2765// successfuly. 2766// 2767// Use "Send" method on the returned Request to send the API call to the service. 2768// the "output" return value is not valid until after Send returns without error. 2769// 2770// See InputService14TestCaseOperation1 for more information on using the InputService14TestCaseOperation1 2771// API call, and error handling. 2772// 2773// This method is useful when you want to inject custom logic or configuration 2774// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2775// 2776// 2777// // Example sending a request using the InputService14TestCaseOperation1Request method. 2778// req, resp := client.InputService14TestCaseOperation1Request(params) 2779// 2780// err := req.Send() 2781// if err == nil { // resp is now filled 2782// fmt.Println(resp) 2783// } 2784func (c *InputService14ProtocolTest) InputService14TestCaseOperation1Request(input *InputService14TestShapeInputService14TestCaseOperation2Input) (req *request.Request, output *InputService14TestShapeInputService14TestCaseOperation1Output) { 2785 op := &request.Operation{ 2786 Name: opInputService14TestCaseOperation1, 2787 HTTPMethod: "POST", 2788 HTTPPath: "/", 2789 } 2790 2791 if input == nil { 2792 input = &InputService14TestShapeInputService14TestCaseOperation2Input{} 2793 } 2794 2795 output = &InputService14TestShapeInputService14TestCaseOperation1Output{} 2796 req = c.newRequest(op, input, output) 2797 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 2798 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2799 return 2800} 2801 2802// InputService14TestCaseOperation1 API operation for . 2803// 2804// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2805// with awserr.Error's Code and Message methods to get detailed information about 2806// the error. 2807// 2808// See the AWS API reference guide for 's 2809// API operation InputService14TestCaseOperation1 for usage and error information. 2810func (c *InputService14ProtocolTest) InputService14TestCaseOperation1(input *InputService14TestShapeInputService14TestCaseOperation2Input) (*InputService14TestShapeInputService14TestCaseOperation1Output, error) { 2811 req, out := c.InputService14TestCaseOperation1Request(input) 2812 return out, req.Send() 2813} 2814 2815// InputService14TestCaseOperation1WithContext is the same as InputService14TestCaseOperation1 with the addition of 2816// the ability to pass a context and additional request options. 2817// 2818// See InputService14TestCaseOperation1 for details on how to use this API operation. 2819// 2820// The context must be non-nil and will be used for request cancellation. If 2821// the context is nil a panic will occur. In the future the SDK may create 2822// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2823// for more information on using Contexts. 2824func (c *InputService14ProtocolTest) InputService14TestCaseOperation1WithContext(ctx aws.Context, input *InputService14TestShapeInputService14TestCaseOperation2Input, opts ...request.Option) (*InputService14TestShapeInputService14TestCaseOperation1Output, error) { 2825 req, out := c.InputService14TestCaseOperation1Request(input) 2826 req.SetContext(ctx) 2827 req.ApplyOptions(opts...) 2828 return out, req.Send() 2829} 2830 2831const opInputService14TestCaseOperation2 = "OperationName" 2832 2833// InputService14TestCaseOperation2Request generates a "aws/request.Request" representing the 2834// client's request for the InputService14TestCaseOperation2 operation. The "output" return 2835// value will be populated with the request's response once the request completes 2836// successfuly. 2837// 2838// Use "Send" method on the returned Request to send the API call to the service. 2839// the "output" return value is not valid until after Send returns without error. 2840// 2841// See InputService14TestCaseOperation2 for more information on using the InputService14TestCaseOperation2 2842// API call, and error handling. 2843// 2844// This method is useful when you want to inject custom logic or configuration 2845// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2846// 2847// 2848// // Example sending a request using the InputService14TestCaseOperation2Request method. 2849// req, resp := client.InputService14TestCaseOperation2Request(params) 2850// 2851// err := req.Send() 2852// if err == nil { // resp is now filled 2853// fmt.Println(resp) 2854// } 2855func (c *InputService14ProtocolTest) InputService14TestCaseOperation2Request(input *InputService14TestShapeInputService14TestCaseOperation2Input) (req *request.Request, output *InputService14TestShapeInputService14TestCaseOperation2Output) { 2856 op := &request.Operation{ 2857 Name: opInputService14TestCaseOperation2, 2858 HTTPMethod: "POST", 2859 HTTPPath: "/", 2860 } 2861 2862 if input == nil { 2863 input = &InputService14TestShapeInputService14TestCaseOperation2Input{} 2864 } 2865 2866 output = &InputService14TestShapeInputService14TestCaseOperation2Output{} 2867 req = c.newRequest(op, input, output) 2868 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 2869 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2870 return 2871} 2872 2873// InputService14TestCaseOperation2 API operation for . 2874// 2875// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2876// with awserr.Error's Code and Message methods to get detailed information about 2877// the error. 2878// 2879// See the AWS API reference guide for 's 2880// API operation InputService14TestCaseOperation2 for usage and error information. 2881func (c *InputService14ProtocolTest) InputService14TestCaseOperation2(input *InputService14TestShapeInputService14TestCaseOperation2Input) (*InputService14TestShapeInputService14TestCaseOperation2Output, error) { 2882 req, out := c.InputService14TestCaseOperation2Request(input) 2883 return out, req.Send() 2884} 2885 2886// InputService14TestCaseOperation2WithContext is the same as InputService14TestCaseOperation2 with the addition of 2887// the ability to pass a context and additional request options. 2888// 2889// See InputService14TestCaseOperation2 for details on how to use this API operation. 2890// 2891// The context must be non-nil and will be used for request cancellation. If 2892// the context is nil a panic will occur. In the future the SDK may create 2893// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2894// for more information on using Contexts. 2895func (c *InputService14ProtocolTest) InputService14TestCaseOperation2WithContext(ctx aws.Context, input *InputService14TestShapeInputService14TestCaseOperation2Input, opts ...request.Option) (*InputService14TestShapeInputService14TestCaseOperation2Output, error) { 2896 req, out := c.InputService14TestCaseOperation2Request(input) 2897 req.SetContext(ctx) 2898 req.ApplyOptions(opts...) 2899 return out, req.Send() 2900} 2901 2902type InputService14TestShapeInputService14TestCaseOperation1Output struct { 2903 _ struct{} `type:"structure"` 2904} 2905 2906type InputService14TestShapeInputService14TestCaseOperation2Input struct { 2907 _ struct{} `type:"structure"` 2908 2909 Token *string `type:"string" idempotencyToken:"true"` 2910} 2911 2912// SetToken sets the Token field's value. 2913func (s *InputService14TestShapeInputService14TestCaseOperation2Input) SetToken(v string) *InputService14TestShapeInputService14TestCaseOperation2Input { 2914 s.Token = &v 2915 return s 2916} 2917 2918type InputService14TestShapeInputService14TestCaseOperation2Output struct { 2919 _ struct{} `type:"structure"` 2920} 2921 2922// InputService15ProtocolTest provides the API operation methods for making requests to 2923// . See this package's package overview docs 2924// for details on the service. 2925// 2926// InputService15ProtocolTest methods are safe to use concurrently. It is not safe to 2927// modify mutate any of the struct's properties though. 2928type InputService15ProtocolTest struct { 2929 *client.Client 2930} 2931 2932// New creates a new instance of the InputService15ProtocolTest client with a session. 2933// If additional configuration is needed for the client instance use the optional 2934// aws.Config parameter to add your extra config. 2935// 2936// Example: 2937// // Create a InputService15ProtocolTest client from just a session. 2938// svc := inputservice15protocoltest.New(mySession) 2939// 2940// // Create a InputService15ProtocolTest client with additional configuration 2941// svc := inputservice15protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2942func NewInputService15ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService15ProtocolTest { 2943 c := p.ClientConfig("inputservice15protocoltest", cfgs...) 2944 return newInputService15ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2945} 2946 2947// newClient creates, initializes and returns a new service client instance. 2948func newInputService15ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService15ProtocolTest { 2949 svc := &InputService15ProtocolTest{ 2950 Client: client.New( 2951 cfg, 2952 metadata.ClientInfo{ 2953 ServiceName: "InputService15ProtocolTest", 2954 ServiceID: "InputService15ProtocolTest", 2955 SigningName: signingName, 2956 SigningRegion: signingRegion, 2957 Endpoint: endpoint, 2958 APIVersion: "2014-01-01", 2959 }, 2960 handlers, 2961 ), 2962 } 2963 2964 // Handlers 2965 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2966 svc.Handlers.Build.PushBackNamed(query.BuildHandler) 2967 svc.Handlers.Unmarshal.PushBackNamed(query.UnmarshalHandler) 2968 svc.Handlers.UnmarshalMeta.PushBackNamed(query.UnmarshalMetaHandler) 2969 svc.Handlers.UnmarshalError.PushBackNamed(query.UnmarshalErrorHandler) 2970 2971 return svc 2972} 2973 2974// newRequest creates a new request for a InputService15ProtocolTest operation and runs any 2975// custom request initialization. 2976func (c *InputService15ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2977 req := c.NewRequest(op, params, data) 2978 2979 return req 2980} 2981 2982const opInputService15TestCaseOperation1 = "OperationName" 2983 2984// InputService15TestCaseOperation1Request generates a "aws/request.Request" representing the 2985// client's request for the InputService15TestCaseOperation1 operation. The "output" return 2986// value will be populated with the request's response once the request completes 2987// successfuly. 2988// 2989// Use "Send" method on the returned Request to send the API call to the service. 2990// the "output" return value is not valid until after Send returns without error. 2991// 2992// See InputService15TestCaseOperation1 for more information on using the InputService15TestCaseOperation1 2993// API call, and error handling. 2994// 2995// This method is useful when you want to inject custom logic or configuration 2996// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2997// 2998// 2999// // Example sending a request using the InputService15TestCaseOperation1Request method. 3000// req, resp := client.InputService15TestCaseOperation1Request(params) 3001// 3002// err := req.Send() 3003// if err == nil { // resp is now filled 3004// fmt.Println(resp) 3005// } 3006func (c *InputService15ProtocolTest) InputService15TestCaseOperation1Request(input *InputService15TestShapeInputService15TestCaseOperation3Input) (req *request.Request, output *InputService15TestShapeInputService15TestCaseOperation1Output) { 3007 op := &request.Operation{ 3008 Name: opInputService15TestCaseOperation1, 3009 HTTPMethod: "POST", 3010 HTTPPath: "/", 3011 } 3012 3013 if input == nil { 3014 input = &InputService15TestShapeInputService15TestCaseOperation3Input{} 3015 } 3016 3017 output = &InputService15TestShapeInputService15TestCaseOperation1Output{} 3018 req = c.newRequest(op, input, output) 3019 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 3020 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 3021 return 3022} 3023 3024// InputService15TestCaseOperation1 API operation for . 3025// 3026// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3027// with awserr.Error's Code and Message methods to get detailed information about 3028// the error. 3029// 3030// See the AWS API reference guide for 's 3031// API operation InputService15TestCaseOperation1 for usage and error information. 3032func (c *InputService15ProtocolTest) InputService15TestCaseOperation1(input *InputService15TestShapeInputService15TestCaseOperation3Input) (*InputService15TestShapeInputService15TestCaseOperation1Output, error) { 3033 req, out := c.InputService15TestCaseOperation1Request(input) 3034 return out, req.Send() 3035} 3036 3037// InputService15TestCaseOperation1WithContext is the same as InputService15TestCaseOperation1 with the addition of 3038// the ability to pass a context and additional request options. 3039// 3040// See InputService15TestCaseOperation1 for details on how to use this API operation. 3041// 3042// The context must be non-nil and will be used for request cancellation. If 3043// the context is nil a panic will occur. In the future the SDK may create 3044// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3045// for more information on using Contexts. 3046func (c *InputService15ProtocolTest) InputService15TestCaseOperation1WithContext(ctx aws.Context, input *InputService15TestShapeInputService15TestCaseOperation3Input, opts ...request.Option) (*InputService15TestShapeInputService15TestCaseOperation1Output, error) { 3047 req, out := c.InputService15TestCaseOperation1Request(input) 3048 req.SetContext(ctx) 3049 req.ApplyOptions(opts...) 3050 return out, req.Send() 3051} 3052 3053const opInputService15TestCaseOperation2 = "OperationName" 3054 3055// InputService15TestCaseOperation2Request generates a "aws/request.Request" representing the 3056// client's request for the InputService15TestCaseOperation2 operation. The "output" return 3057// value will be populated with the request's response once the request completes 3058// successfuly. 3059// 3060// Use "Send" method on the returned Request to send the API call to the service. 3061// the "output" return value is not valid until after Send returns without error. 3062// 3063// See InputService15TestCaseOperation2 for more information on using the InputService15TestCaseOperation2 3064// API call, and error handling. 3065// 3066// This method is useful when you want to inject custom logic or configuration 3067// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3068// 3069// 3070// // Example sending a request using the InputService15TestCaseOperation2Request method. 3071// req, resp := client.InputService15TestCaseOperation2Request(params) 3072// 3073// err := req.Send() 3074// if err == nil { // resp is now filled 3075// fmt.Println(resp) 3076// } 3077func (c *InputService15ProtocolTest) InputService15TestCaseOperation2Request(input *InputService15TestShapeInputService15TestCaseOperation3Input) (req *request.Request, output *InputService15TestShapeInputService15TestCaseOperation2Output) { 3078 op := &request.Operation{ 3079 Name: opInputService15TestCaseOperation2, 3080 HTTPMethod: "POST", 3081 HTTPPath: "/", 3082 } 3083 3084 if input == nil { 3085 input = &InputService15TestShapeInputService15TestCaseOperation3Input{} 3086 } 3087 3088 output = &InputService15TestShapeInputService15TestCaseOperation2Output{} 3089 req = c.newRequest(op, input, output) 3090 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 3091 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 3092 return 3093} 3094 3095// InputService15TestCaseOperation2 API operation for . 3096// 3097// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3098// with awserr.Error's Code and Message methods to get detailed information about 3099// the error. 3100// 3101// See the AWS API reference guide for 's 3102// API operation InputService15TestCaseOperation2 for usage and error information. 3103func (c *InputService15ProtocolTest) InputService15TestCaseOperation2(input *InputService15TestShapeInputService15TestCaseOperation3Input) (*InputService15TestShapeInputService15TestCaseOperation2Output, error) { 3104 req, out := c.InputService15TestCaseOperation2Request(input) 3105 return out, req.Send() 3106} 3107 3108// InputService15TestCaseOperation2WithContext is the same as InputService15TestCaseOperation2 with the addition of 3109// the ability to pass a context and additional request options. 3110// 3111// See InputService15TestCaseOperation2 for details on how to use this API operation. 3112// 3113// The context must be non-nil and will be used for request cancellation. If 3114// the context is nil a panic will occur. In the future the SDK may create 3115// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3116// for more information on using Contexts. 3117func (c *InputService15ProtocolTest) InputService15TestCaseOperation2WithContext(ctx aws.Context, input *InputService15TestShapeInputService15TestCaseOperation3Input, opts ...request.Option) (*InputService15TestShapeInputService15TestCaseOperation2Output, error) { 3118 req, out := c.InputService15TestCaseOperation2Request(input) 3119 req.SetContext(ctx) 3120 req.ApplyOptions(opts...) 3121 return out, req.Send() 3122} 3123 3124const opInputService15TestCaseOperation3 = "OperationName" 3125 3126// InputService15TestCaseOperation3Request generates a "aws/request.Request" representing the 3127// client's request for the InputService15TestCaseOperation3 operation. The "output" return 3128// value will be populated with the request's response once the request completes 3129// successfuly. 3130// 3131// Use "Send" method on the returned Request to send the API call to the service. 3132// the "output" return value is not valid until after Send returns without error. 3133// 3134// See InputService15TestCaseOperation3 for more information on using the InputService15TestCaseOperation3 3135// API call, and error handling. 3136// 3137// This method is useful when you want to inject custom logic or configuration 3138// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3139// 3140// 3141// // Example sending a request using the InputService15TestCaseOperation3Request method. 3142// req, resp := client.InputService15TestCaseOperation3Request(params) 3143// 3144// err := req.Send() 3145// if err == nil { // resp is now filled 3146// fmt.Println(resp) 3147// } 3148func (c *InputService15ProtocolTest) InputService15TestCaseOperation3Request(input *InputService15TestShapeInputService15TestCaseOperation3Input) (req *request.Request, output *InputService15TestShapeInputService15TestCaseOperation3Output) { 3149 op := &request.Operation{ 3150 Name: opInputService15TestCaseOperation3, 3151 HTTPMethod: "POST", 3152 HTTPPath: "/", 3153 } 3154 3155 if input == nil { 3156 input = &InputService15TestShapeInputService15TestCaseOperation3Input{} 3157 } 3158 3159 output = &InputService15TestShapeInputService15TestCaseOperation3Output{} 3160 req = c.newRequest(op, input, output) 3161 req.Handlers.Unmarshal.Remove(query.UnmarshalHandler) 3162 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 3163 return 3164} 3165 3166// InputService15TestCaseOperation3 API operation for . 3167// 3168// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3169// with awserr.Error's Code and Message methods to get detailed information about 3170// the error. 3171// 3172// See the AWS API reference guide for 's 3173// API operation InputService15TestCaseOperation3 for usage and error information. 3174func (c *InputService15ProtocolTest) InputService15TestCaseOperation3(input *InputService15TestShapeInputService15TestCaseOperation3Input) (*InputService15TestShapeInputService15TestCaseOperation3Output, error) { 3175 req, out := c.InputService15TestCaseOperation3Request(input) 3176 return out, req.Send() 3177} 3178 3179// InputService15TestCaseOperation3WithContext is the same as InputService15TestCaseOperation3 with the addition of 3180// the ability to pass a context and additional request options. 3181// 3182// See InputService15TestCaseOperation3 for details on how to use this API operation. 3183// 3184// The context must be non-nil and will be used for request cancellation. If 3185// the context is nil a panic will occur. In the future the SDK may create 3186// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3187// for more information on using Contexts. 3188func (c *InputService15ProtocolTest) InputService15TestCaseOperation3WithContext(ctx aws.Context, input *InputService15TestShapeInputService15TestCaseOperation3Input, opts ...request.Option) (*InputService15TestShapeInputService15TestCaseOperation3Output, error) { 3189 req, out := c.InputService15TestCaseOperation3Request(input) 3190 req.SetContext(ctx) 3191 req.ApplyOptions(opts...) 3192 return out, req.Send() 3193} 3194 3195type InputService15TestShapeInputService15TestCaseOperation1Output struct { 3196 _ struct{} `type:"structure"` 3197} 3198 3199type InputService15TestShapeInputService15TestCaseOperation2Output struct { 3200 _ struct{} `type:"structure"` 3201} 3202 3203type InputService15TestShapeInputService15TestCaseOperation3Input struct { 3204 _ struct{} `type:"structure"` 3205 3206 FooEnum *string `type:"string" enum:"InputService15TestShapeEnumType"` 3207 3208 ListEnums []*string `type:"list"` 3209} 3210 3211// SetFooEnum sets the FooEnum field's value. 3212func (s *InputService15TestShapeInputService15TestCaseOperation3Input) SetFooEnum(v string) *InputService15TestShapeInputService15TestCaseOperation3Input { 3213 s.FooEnum = &v 3214 return s 3215} 3216 3217// SetListEnums sets the ListEnums field's value. 3218func (s *InputService15TestShapeInputService15TestCaseOperation3Input) SetListEnums(v []*string) *InputService15TestShapeInputService15TestCaseOperation3Input { 3219 s.ListEnums = v 3220 return s 3221} 3222 3223type InputService15TestShapeInputService15TestCaseOperation3Output struct { 3224 _ struct{} `type:"structure"` 3225} 3226 3227const ( 3228 // EnumTypeFoo is a InputService15TestShapeEnumType enum value 3229 EnumTypeFoo = "foo" 3230 3231 // EnumTypeBar is a InputService15TestShapeEnumType enum value 3232 EnumTypeBar = "bar" 3233) 3234 3235// 3236// Tests begin here 3237// 3238 3239func TestInputService1ProtocolTestScalarMembersCase1(t *testing.T) { 3240 svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3241 input := &InputService1TestShapeInputService1TestCaseOperation3Input{ 3242 Bar: aws.String("val2"), 3243 Foo: aws.String("val1"), 3244 } 3245 req, _ := svc.InputService1TestCaseOperation1Request(input) 3246 r := req.HTTPRequest 3247 3248 // build request 3249 query.Build(req) 3250 if req.Error != nil { 3251 t.Errorf("expect no error, got %v", req.Error) 3252 } 3253 3254 // assert body 3255 if r.Body == nil { 3256 t.Errorf("expect body not to be nil") 3257 } 3258 body, _ := ioutil.ReadAll(r.Body) 3259 awstesting.AssertQuery(t, `Action=OperationName&Bar=val2&Foo=val1&Version=2014-01-01`, util.Trim(string(body))) 3260 3261 // assert URL 3262 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3263 3264 // assert headers 3265 3266} 3267 3268func TestInputService1ProtocolTestScalarMembersCase2(t *testing.T) { 3269 svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3270 input := &InputService1TestShapeInputService1TestCaseOperation3Input{ 3271 Baz: aws.Bool(true), 3272 } 3273 req, _ := svc.InputService1TestCaseOperation2Request(input) 3274 r := req.HTTPRequest 3275 3276 // build request 3277 query.Build(req) 3278 if req.Error != nil { 3279 t.Errorf("expect no error, got %v", req.Error) 3280 } 3281 3282 // assert body 3283 if r.Body == nil { 3284 t.Errorf("expect body not to be nil") 3285 } 3286 body, _ := ioutil.ReadAll(r.Body) 3287 awstesting.AssertQuery(t, `Action=OperationName&Baz=true&Version=2014-01-01`, util.Trim(string(body))) 3288 3289 // assert URL 3290 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3291 3292 // assert headers 3293 3294} 3295 3296func TestInputService1ProtocolTestScalarMembersCase3(t *testing.T) { 3297 svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3298 input := &InputService1TestShapeInputService1TestCaseOperation3Input{ 3299 Baz: aws.Bool(false), 3300 } 3301 req, _ := svc.InputService1TestCaseOperation3Request(input) 3302 r := req.HTTPRequest 3303 3304 // build request 3305 query.Build(req) 3306 if req.Error != nil { 3307 t.Errorf("expect no error, got %v", req.Error) 3308 } 3309 3310 // assert body 3311 if r.Body == nil { 3312 t.Errorf("expect body not to be nil") 3313 } 3314 body, _ := ioutil.ReadAll(r.Body) 3315 awstesting.AssertQuery(t, `Action=OperationName&Baz=false&Version=2014-01-01`, util.Trim(string(body))) 3316 3317 // assert URL 3318 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3319 3320 // assert headers 3321 3322} 3323 3324func TestInputService2ProtocolTestNestedStructureMembersCase1(t *testing.T) { 3325 svc := NewInputService2ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3326 input := &InputService2TestShapeInputService2TestCaseOperation1Input{ 3327 StructArg: &InputService2TestShapeStructType{ 3328 ScalarArg: aws.String("foo"), 3329 }, 3330 } 3331 req, _ := svc.InputService2TestCaseOperation1Request(input) 3332 r := req.HTTPRequest 3333 3334 // build request 3335 query.Build(req) 3336 if req.Error != nil { 3337 t.Errorf("expect no error, got %v", req.Error) 3338 } 3339 3340 // assert body 3341 if r.Body == nil { 3342 t.Errorf("expect body not to be nil") 3343 } 3344 body, _ := ioutil.ReadAll(r.Body) 3345 awstesting.AssertQuery(t, `Action=OperationName&StructArg.ScalarArg=foo&Version=2014-01-01`, util.Trim(string(body))) 3346 3347 // assert URL 3348 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3349 3350 // assert headers 3351 3352} 3353 3354func TestInputService3ProtocolTestListTypesCase1(t *testing.T) { 3355 svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3356 input := &InputService3TestShapeInputService3TestCaseOperation2Input{ 3357 ListArg: []*string{ 3358 aws.String("foo"), 3359 aws.String("bar"), 3360 aws.String("baz"), 3361 }, 3362 } 3363 req, _ := svc.InputService3TestCaseOperation1Request(input) 3364 r := req.HTTPRequest 3365 3366 // build request 3367 query.Build(req) 3368 if req.Error != nil { 3369 t.Errorf("expect no error, got %v", req.Error) 3370 } 3371 3372 // assert body 3373 if r.Body == nil { 3374 t.Errorf("expect body not to be nil") 3375 } 3376 body, _ := ioutil.ReadAll(r.Body) 3377 awstesting.AssertQuery(t, `Action=OperationName&ListArg.member.1=foo&ListArg.member.2=bar&ListArg.member.3=baz&Version=2014-01-01`, util.Trim(string(body))) 3378 3379 // assert URL 3380 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3381 3382 // assert headers 3383 3384} 3385 3386func TestInputService3ProtocolTestListTypesCase2(t *testing.T) { 3387 svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3388 input := &InputService3TestShapeInputService3TestCaseOperation2Input{ 3389 ListArg: []*string{}, 3390 } 3391 req, _ := svc.InputService3TestCaseOperation2Request(input) 3392 r := req.HTTPRequest 3393 3394 // build request 3395 query.Build(req) 3396 if req.Error != nil { 3397 t.Errorf("expect no error, got %v", req.Error) 3398 } 3399 3400 // assert body 3401 if r.Body == nil { 3402 t.Errorf("expect body not to be nil") 3403 } 3404 body, _ := ioutil.ReadAll(r.Body) 3405 awstesting.AssertQuery(t, `Action=OperationName&ListArg=&Version=2014-01-01`, util.Trim(string(body))) 3406 3407 // assert URL 3408 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3409 3410 // assert headers 3411 3412} 3413 3414func TestInputService4ProtocolTestFlattenedListCase1(t *testing.T) { 3415 svc := NewInputService4ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3416 input := &InputService4TestShapeInputService4TestCaseOperation2Input{ 3417 ListArg: []*string{ 3418 aws.String("a"), 3419 aws.String("b"), 3420 aws.String("c"), 3421 }, 3422 ScalarArg: aws.String("foo"), 3423 } 3424 req, _ := svc.InputService4TestCaseOperation1Request(input) 3425 r := req.HTTPRequest 3426 3427 // build request 3428 query.Build(req) 3429 if req.Error != nil { 3430 t.Errorf("expect no error, got %v", req.Error) 3431 } 3432 3433 // assert body 3434 if r.Body == nil { 3435 t.Errorf("expect body not to be nil") 3436 } 3437 body, _ := ioutil.ReadAll(r.Body) 3438 awstesting.AssertQuery(t, `Action=OperationName&ListArg.1=a&ListArg.2=b&ListArg.3=c&ScalarArg=foo&Version=2014-01-01`, util.Trim(string(body))) 3439 3440 // assert URL 3441 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3442 3443 // assert headers 3444 3445} 3446 3447func TestInputService4ProtocolTestFlattenedListCase2(t *testing.T) { 3448 svc := NewInputService4ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3449 input := &InputService4TestShapeInputService4TestCaseOperation2Input{ 3450 NamedListArg: []*string{ 3451 aws.String("a"), 3452 }, 3453 } 3454 req, _ := svc.InputService4TestCaseOperation2Request(input) 3455 r := req.HTTPRequest 3456 3457 // build request 3458 query.Build(req) 3459 if req.Error != nil { 3460 t.Errorf("expect no error, got %v", req.Error) 3461 } 3462 3463 // assert body 3464 if r.Body == nil { 3465 t.Errorf("expect body not to be nil") 3466 } 3467 body, _ := ioutil.ReadAll(r.Body) 3468 awstesting.AssertQuery(t, `Action=OperationName&Foo.1=a&Version=2014-01-01`, util.Trim(string(body))) 3469 3470 // assert URL 3471 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3472 3473 // assert headers 3474 3475} 3476 3477func TestInputService5ProtocolTestSerializeFlattenedMapTypeCase1(t *testing.T) { 3478 svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3479 input := &InputService5TestShapeInputService5TestCaseOperation1Input{ 3480 MapArg: map[string]*string{ 3481 "key1": aws.String("val1"), 3482 "key2": aws.String("val2"), 3483 }, 3484 } 3485 req, _ := svc.InputService5TestCaseOperation1Request(input) 3486 r := req.HTTPRequest 3487 3488 // build request 3489 query.Build(req) 3490 if req.Error != nil { 3491 t.Errorf("expect no error, got %v", req.Error) 3492 } 3493 3494 // assert body 3495 if r.Body == nil { 3496 t.Errorf("expect body not to be nil") 3497 } 3498 body, _ := ioutil.ReadAll(r.Body) 3499 awstesting.AssertQuery(t, `Action=OperationName&MapArg.1.key=key1&MapArg.1.value=val1&MapArg.2.key=key2&MapArg.2.value=val2&Version=2014-01-01`, util.Trim(string(body))) 3500 3501 // assert URL 3502 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3503 3504 // assert headers 3505 3506} 3507 3508func TestInputService6ProtocolTestNonFlattenedListWithLocationNameCase1(t *testing.T) { 3509 svc := NewInputService6ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3510 input := &InputService6TestShapeInputService6TestCaseOperation1Input{ 3511 ListArg: []*string{ 3512 aws.String("a"), 3513 aws.String("b"), 3514 aws.String("c"), 3515 }, 3516 } 3517 req, _ := svc.InputService6TestCaseOperation1Request(input) 3518 r := req.HTTPRequest 3519 3520 // build request 3521 query.Build(req) 3522 if req.Error != nil { 3523 t.Errorf("expect no error, got %v", req.Error) 3524 } 3525 3526 // assert body 3527 if r.Body == nil { 3528 t.Errorf("expect body not to be nil") 3529 } 3530 body, _ := ioutil.ReadAll(r.Body) 3531 awstesting.AssertQuery(t, `Action=OperationName&ListArg.item.1=a&ListArg.item.2=b&ListArg.item.3=c&Version=2014-01-01`, util.Trim(string(body))) 3532 3533 // assert URL 3534 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3535 3536 // assert headers 3537 3538} 3539 3540func TestInputService7ProtocolTestFlattenedListWithLocationNameCase1(t *testing.T) { 3541 svc := NewInputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3542 input := &InputService7TestShapeInputService7TestCaseOperation1Input{ 3543 ListArg: []*string{ 3544 aws.String("a"), 3545 aws.String("b"), 3546 aws.String("c"), 3547 }, 3548 ScalarArg: aws.String("foo"), 3549 } 3550 req, _ := svc.InputService7TestCaseOperation1Request(input) 3551 r := req.HTTPRequest 3552 3553 // build request 3554 query.Build(req) 3555 if req.Error != nil { 3556 t.Errorf("expect no error, got %v", req.Error) 3557 } 3558 3559 // assert body 3560 if r.Body == nil { 3561 t.Errorf("expect body not to be nil") 3562 } 3563 body, _ := ioutil.ReadAll(r.Body) 3564 awstesting.AssertQuery(t, `Action=OperationName&ListArgLocation.1=a&ListArgLocation.2=b&ListArgLocation.3=c&ScalarArg=foo&Version=2014-01-01`, util.Trim(string(body))) 3565 3566 // assert URL 3567 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3568 3569 // assert headers 3570 3571} 3572 3573func TestInputService8ProtocolTestSerializeMapTypeCase1(t *testing.T) { 3574 svc := NewInputService8ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3575 input := &InputService8TestShapeInputService8TestCaseOperation1Input{ 3576 MapArg: map[string]*string{ 3577 "key1": aws.String("val1"), 3578 "key2": aws.String("val2"), 3579 }, 3580 } 3581 req, _ := svc.InputService8TestCaseOperation1Request(input) 3582 r := req.HTTPRequest 3583 3584 // build request 3585 query.Build(req) 3586 if req.Error != nil { 3587 t.Errorf("expect no error, got %v", req.Error) 3588 } 3589 3590 // assert body 3591 if r.Body == nil { 3592 t.Errorf("expect body not to be nil") 3593 } 3594 body, _ := ioutil.ReadAll(r.Body) 3595 awstesting.AssertQuery(t, `Action=OperationName&MapArg.entry.1.key=key1&MapArg.entry.1.value=val1&MapArg.entry.2.key=key2&MapArg.entry.2.value=val2&Version=2014-01-01`, util.Trim(string(body))) 3596 3597 // assert URL 3598 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3599 3600 // assert headers 3601 3602} 3603 3604func TestInputService9ProtocolTestSerializeMapTypeWithLocationNameCase1(t *testing.T) { 3605 svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3606 input := &InputService9TestShapeInputService9TestCaseOperation1Input{ 3607 MapArg: map[string]*string{ 3608 "key1": aws.String("val1"), 3609 "key2": aws.String("val2"), 3610 }, 3611 } 3612 req, _ := svc.InputService9TestCaseOperation1Request(input) 3613 r := req.HTTPRequest 3614 3615 // build request 3616 query.Build(req) 3617 if req.Error != nil { 3618 t.Errorf("expect no error, got %v", req.Error) 3619 } 3620 3621 // assert body 3622 if r.Body == nil { 3623 t.Errorf("expect body not to be nil") 3624 } 3625 body, _ := ioutil.ReadAll(r.Body) 3626 awstesting.AssertQuery(t, `Action=OperationName&MapArg.entry.1.TheKey=key1&MapArg.entry.1.TheValue=val1&MapArg.entry.2.TheKey=key2&MapArg.entry.2.TheValue=val2&Version=2014-01-01`, util.Trim(string(body))) 3627 3628 // assert URL 3629 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3630 3631 // assert headers 3632 3633} 3634 3635func TestInputService10ProtocolTestBase64EncodedBlobsCase1(t *testing.T) { 3636 svc := NewInputService10ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3637 input := &InputService10TestShapeInputService10TestCaseOperation1Input{ 3638 BlobArg: []byte("foo"), 3639 } 3640 req, _ := svc.InputService10TestCaseOperation1Request(input) 3641 r := req.HTTPRequest 3642 3643 // build request 3644 query.Build(req) 3645 if req.Error != nil { 3646 t.Errorf("expect no error, got %v", req.Error) 3647 } 3648 3649 // assert body 3650 if r.Body == nil { 3651 t.Errorf("expect body not to be nil") 3652 } 3653 body, _ := ioutil.ReadAll(r.Body) 3654 awstesting.AssertQuery(t, `Action=OperationName&BlobArg=Zm9v&Version=2014-01-01`, util.Trim(string(body))) 3655 3656 // assert URL 3657 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3658 3659 // assert headers 3660 3661} 3662 3663func TestInputService11ProtocolTestBase64EncodedBlobsNestedCase1(t *testing.T) { 3664 svc := NewInputService11ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3665 input := &InputService11TestShapeInputService11TestCaseOperation1Input{ 3666 BlobArgs: [][]byte{ 3667 []byte("foo"), 3668 }, 3669 } 3670 req, _ := svc.InputService11TestCaseOperation1Request(input) 3671 r := req.HTTPRequest 3672 3673 // build request 3674 query.Build(req) 3675 if req.Error != nil { 3676 t.Errorf("expect no error, got %v", req.Error) 3677 } 3678 3679 // assert body 3680 if r.Body == nil { 3681 t.Errorf("expect body not to be nil") 3682 } 3683 body, _ := ioutil.ReadAll(r.Body) 3684 awstesting.AssertQuery(t, `Action=OperationName&BlobArgs.1=Zm9v&Version=2014-01-01`, util.Trim(string(body))) 3685 3686 // assert URL 3687 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3688 3689 // assert headers 3690 3691} 3692 3693func TestInputService12ProtocolTestTimestampValuesCase1(t *testing.T) { 3694 svc := NewInputService12ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3695 input := &InputService12TestShapeInputService12TestCaseOperation1Input{ 3696 TimeArg: aws.Time(time.Unix(1422172800, 0)), 3697 } 3698 req, _ := svc.InputService12TestCaseOperation1Request(input) 3699 r := req.HTTPRequest 3700 3701 // build request 3702 query.Build(req) 3703 if req.Error != nil { 3704 t.Errorf("expect no error, got %v", req.Error) 3705 } 3706 3707 // assert body 3708 if r.Body == nil { 3709 t.Errorf("expect body not to be nil") 3710 } 3711 body, _ := ioutil.ReadAll(r.Body) 3712 awstesting.AssertQuery(t, `Action=OperationName&TimeArg=2015-01-25T08%3A00%3A00Z&Version=2014-01-01`, util.Trim(string(body))) 3713 3714 // assert URL 3715 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3716 3717 // assert headers 3718 3719} 3720 3721func TestInputService13ProtocolTestRecursiveShapesCase1(t *testing.T) { 3722 svc := NewInputService13ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3723 input := &InputService13TestShapeInputService13TestCaseOperation6Input{ 3724 RecursiveStruct: &InputService13TestShapeRecursiveStructType{ 3725 NoRecurse: aws.String("foo"), 3726 }, 3727 } 3728 req, _ := svc.InputService13TestCaseOperation1Request(input) 3729 r := req.HTTPRequest 3730 3731 // build request 3732 query.Build(req) 3733 if req.Error != nil { 3734 t.Errorf("expect no error, got %v", req.Error) 3735 } 3736 3737 // assert body 3738 if r.Body == nil { 3739 t.Errorf("expect body not to be nil") 3740 } 3741 body, _ := ioutil.ReadAll(r.Body) 3742 awstesting.AssertQuery(t, `Action=OperationName&RecursiveStruct.NoRecurse=foo&Version=2014-01-01`, util.Trim(string(body))) 3743 3744 // assert URL 3745 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3746 3747 // assert headers 3748 3749} 3750 3751func TestInputService13ProtocolTestRecursiveShapesCase2(t *testing.T) { 3752 svc := NewInputService13ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3753 input := &InputService13TestShapeInputService13TestCaseOperation6Input{ 3754 RecursiveStruct: &InputService13TestShapeRecursiveStructType{ 3755 RecursiveStruct: &InputService13TestShapeRecursiveStructType{ 3756 NoRecurse: aws.String("foo"), 3757 }, 3758 }, 3759 } 3760 req, _ := svc.InputService13TestCaseOperation2Request(input) 3761 r := req.HTTPRequest 3762 3763 // build request 3764 query.Build(req) 3765 if req.Error != nil { 3766 t.Errorf("expect no error, got %v", req.Error) 3767 } 3768 3769 // assert body 3770 if r.Body == nil { 3771 t.Errorf("expect body not to be nil") 3772 } 3773 body, _ := ioutil.ReadAll(r.Body) 3774 awstesting.AssertQuery(t, `Action=OperationName&RecursiveStruct.RecursiveStruct.NoRecurse=foo&Version=2014-01-01`, util.Trim(string(body))) 3775 3776 // assert URL 3777 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3778 3779 // assert headers 3780 3781} 3782 3783func TestInputService13ProtocolTestRecursiveShapesCase3(t *testing.T) { 3784 svc := NewInputService13ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3785 input := &InputService13TestShapeInputService13TestCaseOperation6Input{ 3786 RecursiveStruct: &InputService13TestShapeRecursiveStructType{ 3787 RecursiveStruct: &InputService13TestShapeRecursiveStructType{ 3788 RecursiveStruct: &InputService13TestShapeRecursiveStructType{ 3789 RecursiveStruct: &InputService13TestShapeRecursiveStructType{ 3790 NoRecurse: aws.String("foo"), 3791 }, 3792 }, 3793 }, 3794 }, 3795 } 3796 req, _ := svc.InputService13TestCaseOperation3Request(input) 3797 r := req.HTTPRequest 3798 3799 // build request 3800 query.Build(req) 3801 if req.Error != nil { 3802 t.Errorf("expect no error, got %v", req.Error) 3803 } 3804 3805 // assert body 3806 if r.Body == nil { 3807 t.Errorf("expect body not to be nil") 3808 } 3809 body, _ := ioutil.ReadAll(r.Body) 3810 awstesting.AssertQuery(t, `Action=OperationName&RecursiveStruct.RecursiveStruct.RecursiveStruct.RecursiveStruct.NoRecurse=foo&Version=2014-01-01`, util.Trim(string(body))) 3811 3812 // assert URL 3813 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3814 3815 // assert headers 3816 3817} 3818 3819func TestInputService13ProtocolTestRecursiveShapesCase4(t *testing.T) { 3820 svc := NewInputService13ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3821 input := &InputService13TestShapeInputService13TestCaseOperation6Input{ 3822 RecursiveStruct: &InputService13TestShapeRecursiveStructType{ 3823 RecursiveList: []*InputService13TestShapeRecursiveStructType{ 3824 { 3825 NoRecurse: aws.String("foo"), 3826 }, 3827 { 3828 NoRecurse: aws.String("bar"), 3829 }, 3830 }, 3831 }, 3832 } 3833 req, _ := svc.InputService13TestCaseOperation4Request(input) 3834 r := req.HTTPRequest 3835 3836 // build request 3837 query.Build(req) 3838 if req.Error != nil { 3839 t.Errorf("expect no error, got %v", req.Error) 3840 } 3841 3842 // assert body 3843 if r.Body == nil { 3844 t.Errorf("expect body not to be nil") 3845 } 3846 body, _ := ioutil.ReadAll(r.Body) 3847 awstesting.AssertQuery(t, `Action=OperationName&RecursiveStruct.RecursiveList.member.1.NoRecurse=foo&RecursiveStruct.RecursiveList.member.2.NoRecurse=bar&Version=2014-01-01`, util.Trim(string(body))) 3848 3849 // assert URL 3850 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3851 3852 // assert headers 3853 3854} 3855 3856func TestInputService13ProtocolTestRecursiveShapesCase5(t *testing.T) { 3857 svc := NewInputService13ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3858 input := &InputService13TestShapeInputService13TestCaseOperation6Input{ 3859 RecursiveStruct: &InputService13TestShapeRecursiveStructType{ 3860 RecursiveList: []*InputService13TestShapeRecursiveStructType{ 3861 { 3862 NoRecurse: aws.String("foo"), 3863 }, 3864 { 3865 RecursiveStruct: &InputService13TestShapeRecursiveStructType{ 3866 NoRecurse: aws.String("bar"), 3867 }, 3868 }, 3869 }, 3870 }, 3871 } 3872 req, _ := svc.InputService13TestCaseOperation5Request(input) 3873 r := req.HTTPRequest 3874 3875 // build request 3876 query.Build(req) 3877 if req.Error != nil { 3878 t.Errorf("expect no error, got %v", req.Error) 3879 } 3880 3881 // assert body 3882 if r.Body == nil { 3883 t.Errorf("expect body not to be nil") 3884 } 3885 body, _ := ioutil.ReadAll(r.Body) 3886 awstesting.AssertQuery(t, `Action=OperationName&RecursiveStruct.RecursiveList.member.1.NoRecurse=foo&RecursiveStruct.RecursiveList.member.2.RecursiveStruct.NoRecurse=bar&Version=2014-01-01`, util.Trim(string(body))) 3887 3888 // assert URL 3889 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3890 3891 // assert headers 3892 3893} 3894 3895func TestInputService13ProtocolTestRecursiveShapesCase6(t *testing.T) { 3896 svc := NewInputService13ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3897 input := &InputService13TestShapeInputService13TestCaseOperation6Input{ 3898 RecursiveStruct: &InputService13TestShapeRecursiveStructType{ 3899 RecursiveMap: map[string]*InputService13TestShapeRecursiveStructType{ 3900 "bar": { 3901 NoRecurse: aws.String("bar"), 3902 }, 3903 "foo": { 3904 NoRecurse: aws.String("foo"), 3905 }, 3906 }, 3907 }, 3908 } 3909 req, _ := svc.InputService13TestCaseOperation6Request(input) 3910 r := req.HTTPRequest 3911 3912 // build request 3913 query.Build(req) 3914 if req.Error != nil { 3915 t.Errorf("expect no error, got %v", req.Error) 3916 } 3917 3918 // assert body 3919 if r.Body == nil { 3920 t.Errorf("expect body not to be nil") 3921 } 3922 body, _ := ioutil.ReadAll(r.Body) 3923 awstesting.AssertQuery(t, `Action=OperationName&RecursiveStruct.RecursiveMap.entry.1.key=foo&RecursiveStruct.RecursiveMap.entry.1.value.NoRecurse=foo&RecursiveStruct.RecursiveMap.entry.2.key=bar&RecursiveStruct.RecursiveMap.entry.2.value.NoRecurse=bar&Version=2014-01-01`, util.Trim(string(body))) 3924 3925 // assert URL 3926 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3927 3928 // assert headers 3929 3930} 3931 3932func TestInputService14ProtocolTestIdempotencyTokenAutoFillCase1(t *testing.T) { 3933 svc := NewInputService14ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3934 input := &InputService14TestShapeInputService14TestCaseOperation2Input{ 3935 Token: aws.String("abc123"), 3936 } 3937 req, _ := svc.InputService14TestCaseOperation1Request(input) 3938 r := req.HTTPRequest 3939 3940 // build request 3941 query.Build(req) 3942 if req.Error != nil { 3943 t.Errorf("expect no error, got %v", req.Error) 3944 } 3945 3946 // assert body 3947 if r.Body == nil { 3948 t.Errorf("expect body not to be nil") 3949 } 3950 body, _ := ioutil.ReadAll(r.Body) 3951 awstesting.AssertQuery(t, `Action=OperationName&Token=abc123&Version=2014-01-01`, util.Trim(string(body))) 3952 3953 // assert URL 3954 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3955 3956 // assert headers 3957 3958} 3959 3960func TestInputService14ProtocolTestIdempotencyTokenAutoFillCase2(t *testing.T) { 3961 svc := NewInputService14ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3962 input := &InputService14TestShapeInputService14TestCaseOperation2Input{} 3963 req, _ := svc.InputService14TestCaseOperation2Request(input) 3964 r := req.HTTPRequest 3965 3966 // build request 3967 query.Build(req) 3968 if req.Error != nil { 3969 t.Errorf("expect no error, got %v", req.Error) 3970 } 3971 3972 // assert body 3973 if r.Body == nil { 3974 t.Errorf("expect body not to be nil") 3975 } 3976 body, _ := ioutil.ReadAll(r.Body) 3977 awstesting.AssertQuery(t, `Action=OperationName&Token=00000000-0000-4000-8000-000000000000&Version=2014-01-01`, util.Trim(string(body))) 3978 3979 // assert URL 3980 awstesting.AssertURL(t, "https://test/", r.URL.String()) 3981 3982 // assert headers 3983 3984} 3985 3986func TestInputService15ProtocolTestEnumCase1(t *testing.T) { 3987 svc := NewInputService15ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3988 input := &InputService15TestShapeInputService15TestCaseOperation3Input{ 3989 FooEnum: aws.String("foo"), 3990 ListEnums: []*string{ 3991 aws.String("foo"), 3992 aws.String(""), 3993 aws.String("bar"), 3994 }, 3995 } 3996 req, _ := svc.InputService15TestCaseOperation1Request(input) 3997 r := req.HTTPRequest 3998 3999 // build request 4000 query.Build(req) 4001 if req.Error != nil { 4002 t.Errorf("expect no error, got %v", req.Error) 4003 } 4004 4005 // assert body 4006 if r.Body == nil { 4007 t.Errorf("expect body not to be nil") 4008 } 4009 body, _ := ioutil.ReadAll(r.Body) 4010 awstesting.AssertQuery(t, `Action=OperationName&FooEnum=foo&ListEnums.member.1=foo&ListEnums.member.2=&ListEnums.member.3=bar&Version=2014-01-01`, util.Trim(string(body))) 4011 4012 // assert URL 4013 awstesting.AssertURL(t, "https://test/", r.URL.String()) 4014 4015 // assert headers 4016 4017} 4018 4019func TestInputService15ProtocolTestEnumCase2(t *testing.T) { 4020 svc := NewInputService15ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 4021 input := &InputService15TestShapeInputService15TestCaseOperation3Input{ 4022 FooEnum: aws.String("foo"), 4023 } 4024 req, _ := svc.InputService15TestCaseOperation2Request(input) 4025 r := req.HTTPRequest 4026 4027 // build request 4028 query.Build(req) 4029 if req.Error != nil { 4030 t.Errorf("expect no error, got %v", req.Error) 4031 } 4032 4033 // assert body 4034 if r.Body == nil { 4035 t.Errorf("expect body not to be nil") 4036 } 4037 body, _ := ioutil.ReadAll(r.Body) 4038 awstesting.AssertQuery(t, `Action=OperationName&FooEnum=foo&Version=2014-01-01`, util.Trim(string(body))) 4039 4040 // assert URL 4041 awstesting.AssertURL(t, "https://test/", r.URL.String()) 4042 4043 // assert headers 4044 4045} 4046 4047func TestInputService15ProtocolTestEnumCase3(t *testing.T) { 4048 svc := NewInputService15ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 4049 input := &InputService15TestShapeInputService15TestCaseOperation3Input{} 4050 req, _ := svc.InputService15TestCaseOperation3Request(input) 4051 r := req.HTTPRequest 4052 4053 // build request 4054 query.Build(req) 4055 if req.Error != nil { 4056 t.Errorf("expect no error, got %v", req.Error) 4057 } 4058 4059 // assert body 4060 if r.Body == nil { 4061 t.Errorf("expect body not to be nil") 4062 } 4063 body, _ := ioutil.ReadAll(r.Body) 4064 awstesting.AssertQuery(t, `Action=OperationName&Version=2014-01-01`, util.Trim(string(body))) 4065 4066 // assert URL 4067 awstesting.AssertURL(t, "https://test/", r.URL.String()) 4068 4069 // assert headers 4070 4071} 4072