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