1package restxml_test 2 3import ( 4 "bytes" 5 "encoding/json" 6 "encoding/xml" 7 "fmt" 8 "io" 9 "io/ioutil" 10 "net/http" 11 "net/url" 12 "reflect" 13 "testing" 14 "time" 15 16 "github.com/aws/aws-sdk-go/aws" 17 "github.com/aws/aws-sdk-go/aws/client" 18 "github.com/aws/aws-sdk-go/aws/client/metadata" 19 "github.com/aws/aws-sdk-go/aws/request" 20 "github.com/aws/aws-sdk-go/aws/signer/v4" 21 "github.com/aws/aws-sdk-go/awstesting" 22 "github.com/aws/aws-sdk-go/awstesting/unit" 23 "github.com/aws/aws-sdk-go/private/protocol" 24 "github.com/aws/aws-sdk-go/private/protocol/restxml" 25 "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil" 26 "github.com/aws/aws-sdk-go/private/util" 27) 28 29var _ bytes.Buffer // always import bytes 30var _ http.Request 31var _ json.Marshaler 32var _ time.Time 33var _ xmlutil.XMLNode 34var _ xml.Attr 35var _ = ioutil.Discard 36var _ = util.Trim("") 37var _ = url.Values{} 38var _ = io.EOF 39var _ = aws.String 40var _ = fmt.Println 41var _ = reflect.Value{} 42 43func init() { 44 protocol.RandReader = &awstesting.ZeroReader{} 45} 46 47// InputService1ProtocolTest provides the API operation methods for making requests to 48// . See this package's package overview docs 49// for details on the service. 50// 51// InputService1ProtocolTest methods are safe to use concurrently. It is not safe to 52// modify mutate any of the struct's properties though. 53type InputService1ProtocolTest struct { 54 *client.Client 55} 56 57// New creates a new instance of the InputService1ProtocolTest client with a session. 58// If additional configuration is needed for the client instance use the optional 59// aws.Config parameter to add your extra config. 60// 61// Example: 62// // Create a InputService1ProtocolTest client from just a session. 63// svc := inputservice1protocoltest.New(mySession) 64// 65// // Create a InputService1ProtocolTest client with additional configuration 66// svc := inputservice1protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 67func NewInputService1ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService1ProtocolTest { 68 c := p.ClientConfig("inputservice1protocoltest", cfgs...) 69 return newInputService1ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 70} 71 72// newClient creates, initializes and returns a new service client instance. 73func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService1ProtocolTest { 74 svc := &InputService1ProtocolTest{ 75 Client: client.New( 76 cfg, 77 metadata.ClientInfo{ 78 ServiceName: "InputService1ProtocolTest", 79 ServiceID: "InputService1ProtocolTest", 80 SigningName: signingName, 81 SigningRegion: signingRegion, 82 Endpoint: endpoint, 83 APIVersion: "2014-01-01", 84 }, 85 handlers, 86 ), 87 } 88 89 // Handlers 90 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 91 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 92 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 93 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 94 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 95 96 return svc 97} 98 99// newRequest creates a new request for a InputService1ProtocolTest operation and runs any 100// custom request initialization. 101func (c *InputService1ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 102 req := c.NewRequest(op, params, data) 103 104 return req 105} 106 107const opInputService1TestCaseOperation1 = "OperationName" 108 109// InputService1TestCaseOperation1Request generates a "aws/request.Request" representing the 110// client's request for the InputService1TestCaseOperation1 operation. The "output" return 111// value will be populated with the request's response once the request completes 112// successfully. 113// 114// Use "Send" method on the returned Request to send the API call to the service. 115// the "output" return value is not valid until after Send returns without error. 116// 117// See InputService1TestCaseOperation1 for more information on using the InputService1TestCaseOperation1 118// API call, and error handling. 119// 120// This method is useful when you want to inject custom logic or configuration 121// into the SDK's request lifecycle. Such as custom headers, or retry logic. 122// 123// 124// // Example sending a request using the InputService1TestCaseOperation1Request method. 125// req, resp := client.InputService1TestCaseOperation1Request(params) 126// 127// err := req.Send() 128// if err == nil { // resp is now filled 129// fmt.Println(resp) 130// } 131func (c *InputService1ProtocolTest) InputService1TestCaseOperation1Request(input *InputService1TestShapeInputService1TestCaseOperation1Input) (req *request.Request, output *InputService1TestShapeInputService1TestCaseOperation1Output) { 132 op := &request.Operation{ 133 Name: opInputService1TestCaseOperation1, 134 HTTPMethod: "POST", 135 HTTPPath: "/2014-01-01/hostedzone", 136 } 137 138 if input == nil { 139 input = &InputService1TestShapeInputService1TestCaseOperation1Input{} 140 } 141 142 output = &InputService1TestShapeInputService1TestCaseOperation1Output{} 143 req = c.newRequest(op, input, output) 144 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 145 return 146} 147 148// InputService1TestCaseOperation1 API operation for . 149// 150// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 151// with awserr.Error's Code and Message methods to get detailed information about 152// the error. 153// 154// See the AWS API reference guide for 's 155// API operation InputService1TestCaseOperation1 for usage and error information. 156func (c *InputService1ProtocolTest) InputService1TestCaseOperation1(input *InputService1TestShapeInputService1TestCaseOperation1Input) (*InputService1TestShapeInputService1TestCaseOperation1Output, error) { 157 req, out := c.InputService1TestCaseOperation1Request(input) 158 return out, req.Send() 159} 160 161// InputService1TestCaseOperation1WithContext is the same as InputService1TestCaseOperation1 with the addition of 162// the ability to pass a context and additional request options. 163// 164// See InputService1TestCaseOperation1 for details on how to use this API operation. 165// 166// The context must be non-nil and will be used for request cancellation. If 167// the context is nil a panic will occur. In the future the SDK may create 168// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 169// for more information on using Contexts. 170func (c *InputService1ProtocolTest) InputService1TestCaseOperation1WithContext(ctx aws.Context, input *InputService1TestShapeInputService1TestCaseOperation1Input, opts ...request.Option) (*InputService1TestShapeInputService1TestCaseOperation1Output, error) { 171 req, out := c.InputService1TestCaseOperation1Request(input) 172 req.SetContext(ctx) 173 req.ApplyOptions(opts...) 174 return out, req.Send() 175} 176 177const opInputService1TestCaseOperation2 = "OperationName" 178 179// InputService1TestCaseOperation2Request generates a "aws/request.Request" representing the 180// client's request for the InputService1TestCaseOperation2 operation. The "output" return 181// value will be populated with the request's response once the request completes 182// successfully. 183// 184// Use "Send" method on the returned Request to send the API call to the service. 185// the "output" return value is not valid until after Send returns without error. 186// 187// See InputService1TestCaseOperation2 for more information on using the InputService1TestCaseOperation2 188// API call, and error handling. 189// 190// This method is useful when you want to inject custom logic or configuration 191// into the SDK's request lifecycle. Such as custom headers, or retry logic. 192// 193// 194// // Example sending a request using the InputService1TestCaseOperation2Request method. 195// req, resp := client.InputService1TestCaseOperation2Request(params) 196// 197// err := req.Send() 198// if err == nil { // resp is now filled 199// fmt.Println(resp) 200// } 201func (c *InputService1ProtocolTest) InputService1TestCaseOperation2Request(input *InputService1TestShapeInputService1TestCaseOperation2Input) (req *request.Request, output *InputService1TestShapeInputService1TestCaseOperation2Output) { 202 op := &request.Operation{ 203 Name: opInputService1TestCaseOperation2, 204 HTTPMethod: "PUT", 205 HTTPPath: "/2014-01-01/hostedzone", 206 } 207 208 if input == nil { 209 input = &InputService1TestShapeInputService1TestCaseOperation2Input{} 210 } 211 212 output = &InputService1TestShapeInputService1TestCaseOperation2Output{} 213 req = c.newRequest(op, input, output) 214 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 215 return 216} 217 218// InputService1TestCaseOperation2 API operation for . 219// 220// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 221// with awserr.Error's Code and Message methods to get detailed information about 222// the error. 223// 224// See the AWS API reference guide for 's 225// API operation InputService1TestCaseOperation2 for usage and error information. 226func (c *InputService1ProtocolTest) InputService1TestCaseOperation2(input *InputService1TestShapeInputService1TestCaseOperation2Input) (*InputService1TestShapeInputService1TestCaseOperation2Output, error) { 227 req, out := c.InputService1TestCaseOperation2Request(input) 228 return out, req.Send() 229} 230 231// InputService1TestCaseOperation2WithContext is the same as InputService1TestCaseOperation2 with the addition of 232// the ability to pass a context and additional request options. 233// 234// See InputService1TestCaseOperation2 for details on how to use this API operation. 235// 236// The context must be non-nil and will be used for request cancellation. If 237// the context is nil a panic will occur. In the future the SDK may create 238// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 239// for more information on using Contexts. 240func (c *InputService1ProtocolTest) InputService1TestCaseOperation2WithContext(ctx aws.Context, input *InputService1TestShapeInputService1TestCaseOperation2Input, opts ...request.Option) (*InputService1TestShapeInputService1TestCaseOperation2Output, error) { 241 req, out := c.InputService1TestCaseOperation2Request(input) 242 req.SetContext(ctx) 243 req.ApplyOptions(opts...) 244 return out, req.Send() 245} 246 247const opInputService1TestCaseOperation3 = "OperationName" 248 249// InputService1TestCaseOperation3Request generates a "aws/request.Request" representing the 250// client's request for the InputService1TestCaseOperation3 operation. The "output" return 251// value will be populated with the request's response once the request completes 252// successfully. 253// 254// Use "Send" method on the returned Request to send the API call to the service. 255// the "output" return value is not valid until after Send returns without error. 256// 257// See InputService1TestCaseOperation3 for more information on using the InputService1TestCaseOperation3 258// API call, and error handling. 259// 260// This method is useful when you want to inject custom logic or configuration 261// into the SDK's request lifecycle. Such as custom headers, or retry logic. 262// 263// 264// // Example sending a request using the InputService1TestCaseOperation3Request method. 265// req, resp := client.InputService1TestCaseOperation3Request(params) 266// 267// err := req.Send() 268// if err == nil { // resp is now filled 269// fmt.Println(resp) 270// } 271func (c *InputService1ProtocolTest) InputService1TestCaseOperation3Request(input *InputService1TestShapeInputService1TestCaseOperation3Input) (req *request.Request, output *InputService1TestShapeInputService1TestCaseOperation3Output) { 272 op := &request.Operation{ 273 Name: opInputService1TestCaseOperation3, 274 HTTPMethod: "GET", 275 HTTPPath: "/2014-01-01/hostedzone", 276 } 277 278 if input == nil { 279 input = &InputService1TestShapeInputService1TestCaseOperation3Input{} 280 } 281 282 output = &InputService1TestShapeInputService1TestCaseOperation3Output{} 283 req = c.newRequest(op, input, output) 284 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 285 return 286} 287 288// InputService1TestCaseOperation3 API operation for . 289// 290// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 291// with awserr.Error's Code and Message methods to get detailed information about 292// the error. 293// 294// See the AWS API reference guide for 's 295// API operation InputService1TestCaseOperation3 for usage and error information. 296func (c *InputService1ProtocolTest) InputService1TestCaseOperation3(input *InputService1TestShapeInputService1TestCaseOperation3Input) (*InputService1TestShapeInputService1TestCaseOperation3Output, error) { 297 req, out := c.InputService1TestCaseOperation3Request(input) 298 return out, req.Send() 299} 300 301// InputService1TestCaseOperation3WithContext is the same as InputService1TestCaseOperation3 with the addition of 302// the ability to pass a context and additional request options. 303// 304// See InputService1TestCaseOperation3 for details on how to use this API operation. 305// 306// The context must be non-nil and will be used for request cancellation. If 307// the context is nil a panic will occur. In the future the SDK may create 308// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 309// for more information on using Contexts. 310func (c *InputService1ProtocolTest) InputService1TestCaseOperation3WithContext(ctx aws.Context, input *InputService1TestShapeInputService1TestCaseOperation3Input, opts ...request.Option) (*InputService1TestShapeInputService1TestCaseOperation3Output, error) { 311 req, out := c.InputService1TestCaseOperation3Request(input) 312 req.SetContext(ctx) 313 req.ApplyOptions(opts...) 314 return out, req.Send() 315} 316 317type InputService1TestShapeInputService1TestCaseOperation1Input struct { 318 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 319 320 Description *string `type:"string"` 321 322 Name *string `type:"string"` 323} 324 325// SetDescription sets the Description field's value. 326func (s *InputService1TestShapeInputService1TestCaseOperation1Input) SetDescription(v string) *InputService1TestShapeInputService1TestCaseOperation1Input { 327 s.Description = &v 328 return s 329} 330 331// SetName sets the Name field's value. 332func (s *InputService1TestShapeInputService1TestCaseOperation1Input) SetName(v string) *InputService1TestShapeInputService1TestCaseOperation1Input { 333 s.Name = &v 334 return s 335} 336 337type InputService1TestShapeInputService1TestCaseOperation1Output struct { 338 _ struct{} `type:"structure"` 339} 340 341type InputService1TestShapeInputService1TestCaseOperation2Input struct { 342 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 343 344 Description *string `type:"string"` 345 346 Name *string `type:"string"` 347} 348 349// SetDescription sets the Description field's value. 350func (s *InputService1TestShapeInputService1TestCaseOperation2Input) SetDescription(v string) *InputService1TestShapeInputService1TestCaseOperation2Input { 351 s.Description = &v 352 return s 353} 354 355// SetName sets the Name field's value. 356func (s *InputService1TestShapeInputService1TestCaseOperation2Input) SetName(v string) *InputService1TestShapeInputService1TestCaseOperation2Input { 357 s.Name = &v 358 return s 359} 360 361type InputService1TestShapeInputService1TestCaseOperation2Output struct { 362 _ struct{} `type:"structure"` 363} 364 365type InputService1TestShapeInputService1TestCaseOperation3Input struct { 366 _ struct{} `type:"structure"` 367} 368 369type InputService1TestShapeInputService1TestCaseOperation3Output struct { 370 _ struct{} `type:"structure"` 371} 372 373// InputService2ProtocolTest provides the API operation methods for making requests to 374// . See this package's package overview docs 375// for details on the service. 376// 377// InputService2ProtocolTest methods are safe to use concurrently. It is not safe to 378// modify mutate any of the struct's properties though. 379type InputService2ProtocolTest struct { 380 *client.Client 381} 382 383// New creates a new instance of the InputService2ProtocolTest client with a session. 384// If additional configuration is needed for the client instance use the optional 385// aws.Config parameter to add your extra config. 386// 387// Example: 388// // Create a InputService2ProtocolTest client from just a session. 389// svc := inputservice2protocoltest.New(mySession) 390// 391// // Create a InputService2ProtocolTest client with additional configuration 392// svc := inputservice2protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 393func NewInputService2ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService2ProtocolTest { 394 c := p.ClientConfig("inputservice2protocoltest", cfgs...) 395 return newInputService2ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 396} 397 398// newClient creates, initializes and returns a new service client instance. 399func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService2ProtocolTest { 400 svc := &InputService2ProtocolTest{ 401 Client: client.New( 402 cfg, 403 metadata.ClientInfo{ 404 ServiceName: "InputService2ProtocolTest", 405 ServiceID: "InputService2ProtocolTest", 406 SigningName: signingName, 407 SigningRegion: signingRegion, 408 Endpoint: endpoint, 409 APIVersion: "2014-01-01", 410 }, 411 handlers, 412 ), 413 } 414 415 // Handlers 416 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 417 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 418 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 419 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 420 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 421 422 return svc 423} 424 425// newRequest creates a new request for a InputService2ProtocolTest operation and runs any 426// custom request initialization. 427func (c *InputService2ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 428 req := c.NewRequest(op, params, data) 429 430 return req 431} 432 433const opInputService2TestCaseOperation1 = "OperationName" 434 435// InputService2TestCaseOperation1Request generates a "aws/request.Request" representing the 436// client's request for the InputService2TestCaseOperation1 operation. The "output" return 437// value will be populated with the request's response once the request completes 438// successfully. 439// 440// Use "Send" method on the returned Request to send the API call to the service. 441// the "output" return value is not valid until after Send returns without error. 442// 443// See InputService2TestCaseOperation1 for more information on using the InputService2TestCaseOperation1 444// API call, and error handling. 445// 446// This method is useful when you want to inject custom logic or configuration 447// into the SDK's request lifecycle. Such as custom headers, or retry logic. 448// 449// 450// // Example sending a request using the InputService2TestCaseOperation1Request method. 451// req, resp := client.InputService2TestCaseOperation1Request(params) 452// 453// err := req.Send() 454// if err == nil { // resp is now filled 455// fmt.Println(resp) 456// } 457func (c *InputService2ProtocolTest) InputService2TestCaseOperation1Request(input *InputService2TestShapeInputService2TestCaseOperation1Input) (req *request.Request, output *InputService2TestShapeInputService2TestCaseOperation1Output) { 458 op := &request.Operation{ 459 Name: opInputService2TestCaseOperation1, 460 HTTPMethod: "POST", 461 HTTPPath: "/2014-01-01/hostedzone", 462 } 463 464 if input == nil { 465 input = &InputService2TestShapeInputService2TestCaseOperation1Input{} 466 } 467 468 output = &InputService2TestShapeInputService2TestCaseOperation1Output{} 469 req = c.newRequest(op, input, output) 470 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 471 return 472} 473 474// InputService2TestCaseOperation1 API operation for . 475// 476// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 477// with awserr.Error's Code and Message methods to get detailed information about 478// the error. 479// 480// See the AWS API reference guide for 's 481// API operation InputService2TestCaseOperation1 for usage and error information. 482func (c *InputService2ProtocolTest) InputService2TestCaseOperation1(input *InputService2TestShapeInputService2TestCaseOperation1Input) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) { 483 req, out := c.InputService2TestCaseOperation1Request(input) 484 return out, req.Send() 485} 486 487// InputService2TestCaseOperation1WithContext is the same as InputService2TestCaseOperation1 with the addition of 488// the ability to pass a context and additional request options. 489// 490// See InputService2TestCaseOperation1 for details on how to use this API operation. 491// 492// The context must be non-nil and will be used for request cancellation. If 493// the context is nil a panic will occur. In the future the SDK may create 494// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 495// for more information on using Contexts. 496func (c *InputService2ProtocolTest) InputService2TestCaseOperation1WithContext(ctx aws.Context, input *InputService2TestShapeInputService2TestCaseOperation1Input, opts ...request.Option) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) { 497 req, out := c.InputService2TestCaseOperation1Request(input) 498 req.SetContext(ctx) 499 req.ApplyOptions(opts...) 500 return out, req.Send() 501} 502 503type InputService2TestShapeInputService2TestCaseOperation1Input struct { 504 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 505 506 First *bool `type:"boolean"` 507 508 Fourth *int64 `type:"integer"` 509 510 Second *bool `type:"boolean"` 511 512 Third *float64 `type:"float"` 513} 514 515// SetFirst sets the First field's value. 516func (s *InputService2TestShapeInputService2TestCaseOperation1Input) SetFirst(v bool) *InputService2TestShapeInputService2TestCaseOperation1Input { 517 s.First = &v 518 return s 519} 520 521// SetFourth sets the Fourth field's value. 522func (s *InputService2TestShapeInputService2TestCaseOperation1Input) SetFourth(v int64) *InputService2TestShapeInputService2TestCaseOperation1Input { 523 s.Fourth = &v 524 return s 525} 526 527// SetSecond sets the Second field's value. 528func (s *InputService2TestShapeInputService2TestCaseOperation1Input) SetSecond(v bool) *InputService2TestShapeInputService2TestCaseOperation1Input { 529 s.Second = &v 530 return s 531} 532 533// SetThird sets the Third field's value. 534func (s *InputService2TestShapeInputService2TestCaseOperation1Input) SetThird(v float64) *InputService2TestShapeInputService2TestCaseOperation1Input { 535 s.Third = &v 536 return s 537} 538 539type InputService2TestShapeInputService2TestCaseOperation1Output struct { 540 _ struct{} `type:"structure"` 541} 542 543// InputService3ProtocolTest provides the API operation methods for making requests to 544// . See this package's package overview docs 545// for details on the service. 546// 547// InputService3ProtocolTest methods are safe to use concurrently. It is not safe to 548// modify mutate any of the struct's properties though. 549type InputService3ProtocolTest struct { 550 *client.Client 551} 552 553// New creates a new instance of the InputService3ProtocolTest client with a session. 554// If additional configuration is needed for the client instance use the optional 555// aws.Config parameter to add your extra config. 556// 557// Example: 558// // Create a InputService3ProtocolTest client from just a session. 559// svc := inputservice3protocoltest.New(mySession) 560// 561// // Create a InputService3ProtocolTest client with additional configuration 562// svc := inputservice3protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 563func NewInputService3ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService3ProtocolTest { 564 c := p.ClientConfig("inputservice3protocoltest", cfgs...) 565 return newInputService3ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 566} 567 568// newClient creates, initializes and returns a new service client instance. 569func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService3ProtocolTest { 570 svc := &InputService3ProtocolTest{ 571 Client: client.New( 572 cfg, 573 metadata.ClientInfo{ 574 ServiceName: "InputService3ProtocolTest", 575 ServiceID: "InputService3ProtocolTest", 576 SigningName: signingName, 577 SigningRegion: signingRegion, 578 Endpoint: endpoint, 579 APIVersion: "2014-01-01", 580 }, 581 handlers, 582 ), 583 } 584 585 // Handlers 586 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 587 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 588 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 589 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 590 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 591 592 return svc 593} 594 595// newRequest creates a new request for a InputService3ProtocolTest operation and runs any 596// custom request initialization. 597func (c *InputService3ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 598 req := c.NewRequest(op, params, data) 599 600 return req 601} 602 603const opInputService3TestCaseOperation1 = "OperationName" 604 605// InputService3TestCaseOperation1Request generates a "aws/request.Request" representing the 606// client's request for the InputService3TestCaseOperation1 operation. The "output" return 607// value will be populated with the request's response once the request completes 608// successfully. 609// 610// Use "Send" method on the returned Request to send the API call to the service. 611// the "output" return value is not valid until after Send returns without error. 612// 613// See InputService3TestCaseOperation1 for more information on using the InputService3TestCaseOperation1 614// API call, and error handling. 615// 616// This method is useful when you want to inject custom logic or configuration 617// into the SDK's request lifecycle. Such as custom headers, or retry logic. 618// 619// 620// // Example sending a request using the InputService3TestCaseOperation1Request method. 621// req, resp := client.InputService3TestCaseOperation1Request(params) 622// 623// err := req.Send() 624// if err == nil { // resp is now filled 625// fmt.Println(resp) 626// } 627func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputService3TestCaseOperation1Input) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) { 628 op := &request.Operation{ 629 Name: opInputService3TestCaseOperation1, 630 HTTPMethod: "POST", 631 HTTPPath: "/2014-01-01/hostedzone", 632 } 633 634 if input == nil { 635 input = &InputService3TestShapeInputService3TestCaseOperation1Input{} 636 } 637 638 output = &InputService3TestShapeInputService3TestCaseOperation1Output{} 639 req = c.newRequest(op, input, output) 640 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 641 return 642} 643 644// InputService3TestCaseOperation1 API operation for . 645// 646// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 647// with awserr.Error's Code and Message methods to get detailed information about 648// the error. 649// 650// See the AWS API reference guide for 's 651// API operation InputService3TestCaseOperation1 for usage and error information. 652func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputService3TestCaseOperation1Input) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) { 653 req, out := c.InputService3TestCaseOperation1Request(input) 654 return out, req.Send() 655} 656 657// InputService3TestCaseOperation1WithContext is the same as InputService3TestCaseOperation1 with the addition of 658// the ability to pass a context and additional request options. 659// 660// See InputService3TestCaseOperation1 for details on how to use this API operation. 661// 662// The context must be non-nil and will be used for request cancellation. If 663// the context is nil a panic will occur. In the future the SDK may create 664// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 665// for more information on using Contexts. 666func (c *InputService3ProtocolTest) InputService3TestCaseOperation1WithContext(ctx aws.Context, input *InputService3TestShapeInputService3TestCaseOperation1Input, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) { 667 req, out := c.InputService3TestCaseOperation1Request(input) 668 req.SetContext(ctx) 669 req.ApplyOptions(opts...) 670 return out, req.Send() 671} 672 673const opInputService3TestCaseOperation2 = "OperationName" 674 675// InputService3TestCaseOperation2Request generates a "aws/request.Request" representing the 676// client's request for the InputService3TestCaseOperation2 operation. The "output" return 677// value will be populated with the request's response once the request completes 678// successfully. 679// 680// Use "Send" method on the returned Request to send the API call to the service. 681// the "output" return value is not valid until after Send returns without error. 682// 683// See InputService3TestCaseOperation2 for more information on using the InputService3TestCaseOperation2 684// API call, and error handling. 685// 686// This method is useful when you want to inject custom logic or configuration 687// into the SDK's request lifecycle. Such as custom headers, or retry logic. 688// 689// 690// // Example sending a request using the InputService3TestCaseOperation2Request method. 691// req, resp := client.InputService3TestCaseOperation2Request(params) 692// 693// err := req.Send() 694// if err == nil { // resp is now filled 695// fmt.Println(resp) 696// } 697func (c *InputService3ProtocolTest) InputService3TestCaseOperation2Request(input *InputService3TestShapeInputService3TestCaseOperation2Input) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation2Output) { 698 op := &request.Operation{ 699 Name: opInputService3TestCaseOperation2, 700 HTTPMethod: "POST", 701 HTTPPath: "/2014-01-01/hostedzone", 702 } 703 704 if input == nil { 705 input = &InputService3TestShapeInputService3TestCaseOperation2Input{} 706 } 707 708 output = &InputService3TestShapeInputService3TestCaseOperation2Output{} 709 req = c.newRequest(op, input, output) 710 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 711 return 712} 713 714// InputService3TestCaseOperation2 API operation for . 715// 716// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 717// with awserr.Error's Code and Message methods to get detailed information about 718// the error. 719// 720// See the AWS API reference guide for 's 721// API operation InputService3TestCaseOperation2 for usage and error information. 722func (c *InputService3ProtocolTest) InputService3TestCaseOperation2(input *InputService3TestShapeInputService3TestCaseOperation2Input) (*InputService3TestShapeInputService3TestCaseOperation2Output, error) { 723 req, out := c.InputService3TestCaseOperation2Request(input) 724 return out, req.Send() 725} 726 727// InputService3TestCaseOperation2WithContext is the same as InputService3TestCaseOperation2 with the addition of 728// the ability to pass a context and additional request options. 729// 730// See InputService3TestCaseOperation2 for details on how to use this API operation. 731// 732// The context must be non-nil and will be used for request cancellation. If 733// the context is nil a panic will occur. In the future the SDK may create 734// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 735// for more information on using Contexts. 736func (c *InputService3ProtocolTest) InputService3TestCaseOperation2WithContext(ctx aws.Context, input *InputService3TestShapeInputService3TestCaseOperation2Input, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation2Output, error) { 737 req, out := c.InputService3TestCaseOperation2Request(input) 738 req.SetContext(ctx) 739 req.ApplyOptions(opts...) 740 return out, req.Send() 741} 742 743type InputService3TestShapeInputService3TestCaseOperation1Input struct { 744 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 745 746 Description *string `type:"string"` 747 748 SubStructure *InputService3TestShapeSubStructure `type:"structure"` 749} 750 751// SetDescription sets the Description field's value. 752func (s *InputService3TestShapeInputService3TestCaseOperation1Input) SetDescription(v string) *InputService3TestShapeInputService3TestCaseOperation1Input { 753 s.Description = &v 754 return s 755} 756 757// SetSubStructure sets the SubStructure field's value. 758func (s *InputService3TestShapeInputService3TestCaseOperation1Input) SetSubStructure(v *InputService3TestShapeSubStructure) *InputService3TestShapeInputService3TestCaseOperation1Input { 759 s.SubStructure = v 760 return s 761} 762 763type InputService3TestShapeInputService3TestCaseOperation1Output struct { 764 _ struct{} `type:"structure"` 765} 766 767type InputService3TestShapeInputService3TestCaseOperation2Input struct { 768 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 769 770 Description *string `type:"string"` 771 772 SubStructure *InputService3TestShapeSubStructure `type:"structure"` 773} 774 775// SetDescription sets the Description field's value. 776func (s *InputService3TestShapeInputService3TestCaseOperation2Input) SetDescription(v string) *InputService3TestShapeInputService3TestCaseOperation2Input { 777 s.Description = &v 778 return s 779} 780 781// SetSubStructure sets the SubStructure field's value. 782func (s *InputService3TestShapeInputService3TestCaseOperation2Input) SetSubStructure(v *InputService3TestShapeSubStructure) *InputService3TestShapeInputService3TestCaseOperation2Input { 783 s.SubStructure = v 784 return s 785} 786 787type InputService3TestShapeInputService3TestCaseOperation2Output struct { 788 _ struct{} `type:"structure"` 789} 790 791type InputService3TestShapeSubStructure struct { 792 _ struct{} `type:"structure"` 793 794 Bar *string `type:"string"` 795 796 Foo *string `type:"string"` 797} 798 799// SetBar sets the Bar field's value. 800func (s *InputService3TestShapeSubStructure) SetBar(v string) *InputService3TestShapeSubStructure { 801 s.Bar = &v 802 return s 803} 804 805// SetFoo sets the Foo field's value. 806func (s *InputService3TestShapeSubStructure) SetFoo(v string) *InputService3TestShapeSubStructure { 807 s.Foo = &v 808 return s 809} 810 811// InputService4ProtocolTest provides the API operation methods for making requests to 812// . See this package's package overview docs 813// for details on the service. 814// 815// InputService4ProtocolTest methods are safe to use concurrently. It is not safe to 816// modify mutate any of the struct's properties though. 817type InputService4ProtocolTest struct { 818 *client.Client 819} 820 821// New creates a new instance of the InputService4ProtocolTest client with a session. 822// If additional configuration is needed for the client instance use the optional 823// aws.Config parameter to add your extra config. 824// 825// Example: 826// // Create a InputService4ProtocolTest client from just a session. 827// svc := inputservice4protocoltest.New(mySession) 828// 829// // Create a InputService4ProtocolTest client with additional configuration 830// svc := inputservice4protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 831func NewInputService4ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService4ProtocolTest { 832 c := p.ClientConfig("inputservice4protocoltest", cfgs...) 833 return newInputService4ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 834} 835 836// newClient creates, initializes and returns a new service client instance. 837func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService4ProtocolTest { 838 svc := &InputService4ProtocolTest{ 839 Client: client.New( 840 cfg, 841 metadata.ClientInfo{ 842 ServiceName: "InputService4ProtocolTest", 843 ServiceID: "InputService4ProtocolTest", 844 SigningName: signingName, 845 SigningRegion: signingRegion, 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(restxml.BuildHandler) 856 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 857 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 858 svc.Handlers.UnmarshalError.PushBackNamed(restxml.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 HTTPMethod: "POST", 899 HTTPPath: "/2014-01-01/hostedzone", 900 } 901 902 if input == nil { 903 input = &InputService4TestShapeInputService4TestCaseOperation1Input{} 904 } 905 906 output = &InputService4TestShapeInputService4TestCaseOperation1Output{} 907 req = c.newRequest(op, input, output) 908 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 909 return 910} 911 912// InputService4TestCaseOperation1 API operation for . 913// 914// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 915// with awserr.Error's Code and Message methods to get detailed information about 916// the error. 917// 918// See the AWS API reference guide for 's 919// API operation InputService4TestCaseOperation1 for usage and error information. 920func (c *InputService4ProtocolTest) InputService4TestCaseOperation1(input *InputService4TestShapeInputService4TestCaseOperation1Input) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) { 921 req, out := c.InputService4TestCaseOperation1Request(input) 922 return out, req.Send() 923} 924 925// InputService4TestCaseOperation1WithContext is the same as InputService4TestCaseOperation1 with the addition of 926// the ability to pass a context and additional request options. 927// 928// See InputService4TestCaseOperation1 for details on how to use this API operation. 929// 930// The context must be non-nil and will be used for request cancellation. If 931// the context is nil a panic will occur. In the future the SDK may create 932// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 933// for more information on using Contexts. 934func (c *InputService4ProtocolTest) InputService4TestCaseOperation1WithContext(ctx aws.Context, input *InputService4TestShapeInputService4TestCaseOperation1Input, opts ...request.Option) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) { 935 req, out := c.InputService4TestCaseOperation1Request(input) 936 req.SetContext(ctx) 937 req.ApplyOptions(opts...) 938 return out, req.Send() 939} 940 941type InputService4TestShapeInputService4TestCaseOperation1Input struct { 942 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 943 944 Description *string `type:"string"` 945 946 SubStructure *InputService4TestShapeSubStructure `type:"structure"` 947} 948 949// SetDescription sets the Description field's value. 950func (s *InputService4TestShapeInputService4TestCaseOperation1Input) SetDescription(v string) *InputService4TestShapeInputService4TestCaseOperation1Input { 951 s.Description = &v 952 return s 953} 954 955// SetSubStructure sets the SubStructure field's value. 956func (s *InputService4TestShapeInputService4TestCaseOperation1Input) SetSubStructure(v *InputService4TestShapeSubStructure) *InputService4TestShapeInputService4TestCaseOperation1Input { 957 s.SubStructure = v 958 return s 959} 960 961type InputService4TestShapeInputService4TestCaseOperation1Output struct { 962 _ struct{} `type:"structure"` 963} 964 965type InputService4TestShapeSubStructure struct { 966 _ struct{} `type:"structure"` 967 968 Bar *string `type:"string"` 969 970 Foo *string `type:"string"` 971} 972 973// SetBar sets the Bar field's value. 974func (s *InputService4TestShapeSubStructure) SetBar(v string) *InputService4TestShapeSubStructure { 975 s.Bar = &v 976 return s 977} 978 979// SetFoo sets the Foo field's value. 980func (s *InputService4TestShapeSubStructure) SetFoo(v string) *InputService4TestShapeSubStructure { 981 s.Foo = &v 982 return s 983} 984 985// InputService5ProtocolTest provides the API operation methods for making requests to 986// . See this package's package overview docs 987// for details on the service. 988// 989// InputService5ProtocolTest methods are safe to use concurrently. It is not safe to 990// modify mutate any of the struct's properties though. 991type InputService5ProtocolTest struct { 992 *client.Client 993} 994 995// New creates a new instance of the InputService5ProtocolTest client with a session. 996// If additional configuration is needed for the client instance use the optional 997// aws.Config parameter to add your extra config. 998// 999// Example: 1000// // Create a InputService5ProtocolTest client from just a session. 1001// svc := inputservice5protocoltest.New(mySession) 1002// 1003// // Create a InputService5ProtocolTest client with additional configuration 1004// svc := inputservice5protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1005func NewInputService5ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService5ProtocolTest { 1006 c := p.ClientConfig("inputservice5protocoltest", cfgs...) 1007 return newInputService5ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1008} 1009 1010// newClient creates, initializes and returns a new service client instance. 1011func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService5ProtocolTest { 1012 svc := &InputService5ProtocolTest{ 1013 Client: client.New( 1014 cfg, 1015 metadata.ClientInfo{ 1016 ServiceName: "InputService5ProtocolTest", 1017 ServiceID: "InputService5ProtocolTest", 1018 SigningName: signingName, 1019 SigningRegion: signingRegion, 1020 Endpoint: endpoint, 1021 APIVersion: "2014-01-01", 1022 }, 1023 handlers, 1024 ), 1025 } 1026 1027 // Handlers 1028 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1029 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1030 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1031 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1032 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1033 1034 return svc 1035} 1036 1037// newRequest creates a new request for a InputService5ProtocolTest operation and runs any 1038// custom request initialization. 1039func (c *InputService5ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1040 req := c.NewRequest(op, params, data) 1041 1042 return req 1043} 1044 1045const opInputService5TestCaseOperation1 = "OperationName" 1046 1047// InputService5TestCaseOperation1Request generates a "aws/request.Request" representing the 1048// client's request for the InputService5TestCaseOperation1 operation. The "output" return 1049// value will be populated with the request's response once the request completes 1050// successfully. 1051// 1052// Use "Send" method on the returned Request to send the API call to the service. 1053// the "output" return value is not valid until after Send returns without error. 1054// 1055// See InputService5TestCaseOperation1 for more information on using the InputService5TestCaseOperation1 1056// API call, and error handling. 1057// 1058// This method is useful when you want to inject custom logic or configuration 1059// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1060// 1061// 1062// // Example sending a request using the InputService5TestCaseOperation1Request method. 1063// req, resp := client.InputService5TestCaseOperation1Request(params) 1064// 1065// err := req.Send() 1066// if err == nil { // resp is now filled 1067// fmt.Println(resp) 1068// } 1069func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputService5TestCaseOperation1Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) { 1070 op := &request.Operation{ 1071 Name: opInputService5TestCaseOperation1, 1072 HTTPMethod: "POST", 1073 HTTPPath: "/2014-01-01/hostedzone", 1074 } 1075 1076 if input == nil { 1077 input = &InputService5TestShapeInputService5TestCaseOperation1Input{} 1078 } 1079 1080 output = &InputService5TestShapeInputService5TestCaseOperation1Output{} 1081 req = c.newRequest(op, input, output) 1082 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1083 return 1084} 1085 1086// InputService5TestCaseOperation1 API operation for . 1087// 1088// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1089// with awserr.Error's Code and Message methods to get detailed information about 1090// the error. 1091// 1092// See the AWS API reference guide for 's 1093// API operation InputService5TestCaseOperation1 for usage and error information. 1094func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputService5TestCaseOperation1Input) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) { 1095 req, out := c.InputService5TestCaseOperation1Request(input) 1096 return out, req.Send() 1097} 1098 1099// InputService5TestCaseOperation1WithContext is the same as InputService5TestCaseOperation1 with the addition of 1100// the ability to pass a context and additional request options. 1101// 1102// See InputService5TestCaseOperation1 for details on how to use this API operation. 1103// 1104// The context must be non-nil and will be used for request cancellation. If 1105// the context is nil a panic will occur. In the future the SDK may create 1106// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1107// for more information on using Contexts. 1108func (c *InputService5ProtocolTest) InputService5TestCaseOperation1WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation1Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) { 1109 req, out := c.InputService5TestCaseOperation1Request(input) 1110 req.SetContext(ctx) 1111 req.ApplyOptions(opts...) 1112 return out, req.Send() 1113} 1114 1115type InputService5TestShapeInputService5TestCaseOperation1Input struct { 1116 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 1117 1118 ListParam []*string `type:"list"` 1119} 1120 1121// SetListParam sets the ListParam field's value. 1122func (s *InputService5TestShapeInputService5TestCaseOperation1Input) SetListParam(v []*string) *InputService5TestShapeInputService5TestCaseOperation1Input { 1123 s.ListParam = v 1124 return s 1125} 1126 1127type InputService5TestShapeInputService5TestCaseOperation1Output struct { 1128 _ struct{} `type:"structure"` 1129} 1130 1131// InputService6ProtocolTest provides the API operation methods for making requests to 1132// . See this package's package overview docs 1133// for details on the service. 1134// 1135// InputService6ProtocolTest methods are safe to use concurrently. It is not safe to 1136// modify mutate any of the struct's properties though. 1137type InputService6ProtocolTest struct { 1138 *client.Client 1139} 1140 1141// New creates a new instance of the InputService6ProtocolTest client with a session. 1142// If additional configuration is needed for the client instance use the optional 1143// aws.Config parameter to add your extra config. 1144// 1145// Example: 1146// // Create a InputService6ProtocolTest client from just a session. 1147// svc := inputservice6protocoltest.New(mySession) 1148// 1149// // Create a InputService6ProtocolTest client with additional configuration 1150// svc := inputservice6protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1151func NewInputService6ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService6ProtocolTest { 1152 c := p.ClientConfig("inputservice6protocoltest", cfgs...) 1153 return newInputService6ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1154} 1155 1156// newClient creates, initializes and returns a new service client instance. 1157func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService6ProtocolTest { 1158 svc := &InputService6ProtocolTest{ 1159 Client: client.New( 1160 cfg, 1161 metadata.ClientInfo{ 1162 ServiceName: "InputService6ProtocolTest", 1163 ServiceID: "InputService6ProtocolTest", 1164 SigningName: signingName, 1165 SigningRegion: signingRegion, 1166 Endpoint: endpoint, 1167 APIVersion: "2014-01-01", 1168 }, 1169 handlers, 1170 ), 1171 } 1172 1173 // Handlers 1174 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1175 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1176 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1177 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1178 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1179 1180 return svc 1181} 1182 1183// newRequest creates a new request for a InputService6ProtocolTest operation and runs any 1184// custom request initialization. 1185func (c *InputService6ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1186 req := c.NewRequest(op, params, data) 1187 1188 return req 1189} 1190 1191const opInputService6TestCaseOperation1 = "OperationName" 1192 1193// InputService6TestCaseOperation1Request generates a "aws/request.Request" representing the 1194// client's request for the InputService6TestCaseOperation1 operation. The "output" return 1195// value will be populated with the request's response once the request completes 1196// successfully. 1197// 1198// Use "Send" method on the returned Request to send the API call to the service. 1199// the "output" return value is not valid until after Send returns without error. 1200// 1201// See InputService6TestCaseOperation1 for more information on using the InputService6TestCaseOperation1 1202// API call, and error handling. 1203// 1204// This method is useful when you want to inject custom logic or configuration 1205// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1206// 1207// 1208// // Example sending a request using the InputService6TestCaseOperation1Request method. 1209// req, resp := client.InputService6TestCaseOperation1Request(params) 1210// 1211// err := req.Send() 1212// if err == nil { // resp is now filled 1213// fmt.Println(resp) 1214// } 1215func (c *InputService6ProtocolTest) InputService6TestCaseOperation1Request(input *InputService6TestShapeInputService6TestCaseOperation1Input) (req *request.Request, output *InputService6TestShapeInputService6TestCaseOperation1Output) { 1216 op := &request.Operation{ 1217 Name: opInputService6TestCaseOperation1, 1218 HTTPMethod: "POST", 1219 HTTPPath: "/2014-01-01/hostedzone", 1220 } 1221 1222 if input == nil { 1223 input = &InputService6TestShapeInputService6TestCaseOperation1Input{} 1224 } 1225 1226 output = &InputService6TestShapeInputService6TestCaseOperation1Output{} 1227 req = c.newRequest(op, input, output) 1228 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1229 return 1230} 1231 1232// InputService6TestCaseOperation1 API operation for . 1233// 1234// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1235// with awserr.Error's Code and Message methods to get detailed information about 1236// the error. 1237// 1238// See the AWS API reference guide for 's 1239// API operation InputService6TestCaseOperation1 for usage and error information. 1240func (c *InputService6ProtocolTest) InputService6TestCaseOperation1(input *InputService6TestShapeInputService6TestCaseOperation1Input) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) { 1241 req, out := c.InputService6TestCaseOperation1Request(input) 1242 return out, req.Send() 1243} 1244 1245// InputService6TestCaseOperation1WithContext is the same as InputService6TestCaseOperation1 with the addition of 1246// the ability to pass a context and additional request options. 1247// 1248// See InputService6TestCaseOperation1 for details on how to use this API operation. 1249// 1250// The context must be non-nil and will be used for request cancellation. If 1251// the context is nil a panic will occur. In the future the SDK may create 1252// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1253// for more information on using Contexts. 1254func (c *InputService6ProtocolTest) InputService6TestCaseOperation1WithContext(ctx aws.Context, input *InputService6TestShapeInputService6TestCaseOperation1Input, opts ...request.Option) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) { 1255 req, out := c.InputService6TestCaseOperation1Request(input) 1256 req.SetContext(ctx) 1257 req.ApplyOptions(opts...) 1258 return out, req.Send() 1259} 1260 1261type InputService6TestShapeInputService6TestCaseOperation1Input struct { 1262 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 1263 1264 ListParam []*string `locationName:"AlternateName" locationNameList:"NotMember" type:"list"` 1265} 1266 1267// SetListParam sets the ListParam field's value. 1268func (s *InputService6TestShapeInputService6TestCaseOperation1Input) SetListParam(v []*string) *InputService6TestShapeInputService6TestCaseOperation1Input { 1269 s.ListParam = v 1270 return s 1271} 1272 1273type InputService6TestShapeInputService6TestCaseOperation1Output struct { 1274 _ struct{} `type:"structure"` 1275} 1276 1277// InputService7ProtocolTest provides the API operation methods for making requests to 1278// . See this package's package overview docs 1279// for details on the service. 1280// 1281// InputService7ProtocolTest methods are safe to use concurrently. It is not safe to 1282// modify mutate any of the struct's properties though. 1283type InputService7ProtocolTest struct { 1284 *client.Client 1285} 1286 1287// New creates a new instance of the InputService7ProtocolTest client with a session. 1288// If additional configuration is needed for the client instance use the optional 1289// aws.Config parameter to add your extra config. 1290// 1291// Example: 1292// // Create a InputService7ProtocolTest client from just a session. 1293// svc := inputservice7protocoltest.New(mySession) 1294// 1295// // Create a InputService7ProtocolTest client with additional configuration 1296// svc := inputservice7protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1297func NewInputService7ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService7ProtocolTest { 1298 c := p.ClientConfig("inputservice7protocoltest", cfgs...) 1299 return newInputService7ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1300} 1301 1302// newClient creates, initializes and returns a new service client instance. 1303func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService7ProtocolTest { 1304 svc := &InputService7ProtocolTest{ 1305 Client: client.New( 1306 cfg, 1307 metadata.ClientInfo{ 1308 ServiceName: "InputService7ProtocolTest", 1309 ServiceID: "InputService7ProtocolTest", 1310 SigningName: signingName, 1311 SigningRegion: signingRegion, 1312 Endpoint: endpoint, 1313 APIVersion: "2014-01-01", 1314 }, 1315 handlers, 1316 ), 1317 } 1318 1319 // Handlers 1320 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1321 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1322 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1323 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1324 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1325 1326 return svc 1327} 1328 1329// newRequest creates a new request for a InputService7ProtocolTest operation and runs any 1330// custom request initialization. 1331func (c *InputService7ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1332 req := c.NewRequest(op, params, data) 1333 1334 return req 1335} 1336 1337const opInputService7TestCaseOperation1 = "OperationName" 1338 1339// InputService7TestCaseOperation1Request generates a "aws/request.Request" representing the 1340// client's request for the InputService7TestCaseOperation1 operation. The "output" return 1341// value will be populated with the request's response once the request completes 1342// successfully. 1343// 1344// Use "Send" method on the returned Request to send the API call to the service. 1345// the "output" return value is not valid until after Send returns without error. 1346// 1347// See InputService7TestCaseOperation1 for more information on using the InputService7TestCaseOperation1 1348// API call, and error handling. 1349// 1350// This method is useful when you want to inject custom logic or configuration 1351// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1352// 1353// 1354// // Example sending a request using the InputService7TestCaseOperation1Request method. 1355// req, resp := client.InputService7TestCaseOperation1Request(params) 1356// 1357// err := req.Send() 1358// if err == nil { // resp is now filled 1359// fmt.Println(resp) 1360// } 1361func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputService7TestCaseOperation1Input) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) { 1362 op := &request.Operation{ 1363 Name: opInputService7TestCaseOperation1, 1364 HTTPMethod: "POST", 1365 HTTPPath: "/2014-01-01/hostedzone", 1366 } 1367 1368 if input == nil { 1369 input = &InputService7TestShapeInputService7TestCaseOperation1Input{} 1370 } 1371 1372 output = &InputService7TestShapeInputService7TestCaseOperation1Output{} 1373 req = c.newRequest(op, input, output) 1374 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1375 return 1376} 1377 1378// InputService7TestCaseOperation1 API operation for . 1379// 1380// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1381// with awserr.Error's Code and Message methods to get detailed information about 1382// the error. 1383// 1384// See the AWS API reference guide for 's 1385// API operation InputService7TestCaseOperation1 for usage and error information. 1386func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputService7TestCaseOperation1Input) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) { 1387 req, out := c.InputService7TestCaseOperation1Request(input) 1388 return out, req.Send() 1389} 1390 1391// InputService7TestCaseOperation1WithContext is the same as InputService7TestCaseOperation1 with the addition of 1392// the ability to pass a context and additional request options. 1393// 1394// See InputService7TestCaseOperation1 for details on how to use this API operation. 1395// 1396// The context must be non-nil and will be used for request cancellation. If 1397// the context is nil a panic will occur. In the future the SDK may create 1398// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1399// for more information on using Contexts. 1400func (c *InputService7ProtocolTest) InputService7TestCaseOperation1WithContext(ctx aws.Context, input *InputService7TestShapeInputService7TestCaseOperation1Input, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) { 1401 req, out := c.InputService7TestCaseOperation1Request(input) 1402 req.SetContext(ctx) 1403 req.ApplyOptions(opts...) 1404 return out, req.Send() 1405} 1406 1407type InputService7TestShapeInputService7TestCaseOperation1Input struct { 1408 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 1409 1410 ListParam []*string `type:"list" flattened:"true"` 1411} 1412 1413// SetListParam sets the ListParam field's value. 1414func (s *InputService7TestShapeInputService7TestCaseOperation1Input) SetListParam(v []*string) *InputService7TestShapeInputService7TestCaseOperation1Input { 1415 s.ListParam = v 1416 return s 1417} 1418 1419type InputService7TestShapeInputService7TestCaseOperation1Output struct { 1420 _ struct{} `type:"structure"` 1421} 1422 1423// InputService8ProtocolTest provides the API operation methods for making requests to 1424// . See this package's package overview docs 1425// for details on the service. 1426// 1427// InputService8ProtocolTest methods are safe to use concurrently. It is not safe to 1428// modify mutate any of the struct's properties though. 1429type InputService8ProtocolTest struct { 1430 *client.Client 1431} 1432 1433// New creates a new instance of the InputService8ProtocolTest client with a session. 1434// If additional configuration is needed for the client instance use the optional 1435// aws.Config parameter to add your extra config. 1436// 1437// Example: 1438// // Create a InputService8ProtocolTest client from just a session. 1439// svc := inputservice8protocoltest.New(mySession) 1440// 1441// // Create a InputService8ProtocolTest client with additional configuration 1442// svc := inputservice8protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1443func NewInputService8ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService8ProtocolTest { 1444 c := p.ClientConfig("inputservice8protocoltest", cfgs...) 1445 return newInputService8ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1446} 1447 1448// newClient creates, initializes and returns a new service client instance. 1449func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService8ProtocolTest { 1450 svc := &InputService8ProtocolTest{ 1451 Client: client.New( 1452 cfg, 1453 metadata.ClientInfo{ 1454 ServiceName: "InputService8ProtocolTest", 1455 ServiceID: "InputService8ProtocolTest", 1456 SigningName: signingName, 1457 SigningRegion: signingRegion, 1458 Endpoint: endpoint, 1459 APIVersion: "2014-01-01", 1460 }, 1461 handlers, 1462 ), 1463 } 1464 1465 // Handlers 1466 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1467 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1468 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1469 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1470 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1471 1472 return svc 1473} 1474 1475// newRequest creates a new request for a InputService8ProtocolTest operation and runs any 1476// custom request initialization. 1477func (c *InputService8ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1478 req := c.NewRequest(op, params, data) 1479 1480 return req 1481} 1482 1483const opInputService8TestCaseOperation1 = "OperationName" 1484 1485// InputService8TestCaseOperation1Request generates a "aws/request.Request" representing the 1486// client's request for the InputService8TestCaseOperation1 operation. The "output" return 1487// value will be populated with the request's response once the request completes 1488// successfully. 1489// 1490// Use "Send" method on the returned Request to send the API call to the service. 1491// the "output" return value is not valid until after Send returns without error. 1492// 1493// See InputService8TestCaseOperation1 for more information on using the InputService8TestCaseOperation1 1494// API call, and error handling. 1495// 1496// This method is useful when you want to inject custom logic or configuration 1497// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1498// 1499// 1500// // Example sending a request using the InputService8TestCaseOperation1Request method. 1501// req, resp := client.InputService8TestCaseOperation1Request(params) 1502// 1503// err := req.Send() 1504// if err == nil { // resp is now filled 1505// fmt.Println(resp) 1506// } 1507func (c *InputService8ProtocolTest) InputService8TestCaseOperation1Request(input *InputService8TestShapeInputService8TestCaseOperation1Input) (req *request.Request, output *InputService8TestShapeInputService8TestCaseOperation1Output) { 1508 op := &request.Operation{ 1509 Name: opInputService8TestCaseOperation1, 1510 HTTPMethod: "POST", 1511 HTTPPath: "/2014-01-01/hostedzone", 1512 } 1513 1514 if input == nil { 1515 input = &InputService8TestShapeInputService8TestCaseOperation1Input{} 1516 } 1517 1518 output = &InputService8TestShapeInputService8TestCaseOperation1Output{} 1519 req = c.newRequest(op, input, output) 1520 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1521 return 1522} 1523 1524// InputService8TestCaseOperation1 API operation for . 1525// 1526// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1527// with awserr.Error's Code and Message methods to get detailed information about 1528// the error. 1529// 1530// See the AWS API reference guide for 's 1531// API operation InputService8TestCaseOperation1 for usage and error information. 1532func (c *InputService8ProtocolTest) InputService8TestCaseOperation1(input *InputService8TestShapeInputService8TestCaseOperation1Input) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) { 1533 req, out := c.InputService8TestCaseOperation1Request(input) 1534 return out, req.Send() 1535} 1536 1537// InputService8TestCaseOperation1WithContext is the same as InputService8TestCaseOperation1 with the addition of 1538// the ability to pass a context and additional request options. 1539// 1540// See InputService8TestCaseOperation1 for details on how to use this API operation. 1541// 1542// The context must be non-nil and will be used for request cancellation. If 1543// the context is nil a panic will occur. In the future the SDK may create 1544// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1545// for more information on using Contexts. 1546func (c *InputService8ProtocolTest) InputService8TestCaseOperation1WithContext(ctx aws.Context, input *InputService8TestShapeInputService8TestCaseOperation1Input, opts ...request.Option) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) { 1547 req, out := c.InputService8TestCaseOperation1Request(input) 1548 req.SetContext(ctx) 1549 req.ApplyOptions(opts...) 1550 return out, req.Send() 1551} 1552 1553type InputService8TestShapeInputService8TestCaseOperation1Input struct { 1554 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 1555 1556 ListParam []*string `locationName:"item" type:"list" flattened:"true"` 1557} 1558 1559// SetListParam sets the ListParam field's value. 1560func (s *InputService8TestShapeInputService8TestCaseOperation1Input) SetListParam(v []*string) *InputService8TestShapeInputService8TestCaseOperation1Input { 1561 s.ListParam = v 1562 return s 1563} 1564 1565type InputService8TestShapeInputService8TestCaseOperation1Output struct { 1566 _ struct{} `type:"structure"` 1567} 1568 1569// InputService9ProtocolTest provides the API operation methods for making requests to 1570// . See this package's package overview docs 1571// for details on the service. 1572// 1573// InputService9ProtocolTest methods are safe to use concurrently. It is not safe to 1574// modify mutate any of the struct's properties though. 1575type InputService9ProtocolTest struct { 1576 *client.Client 1577} 1578 1579// New creates a new instance of the InputService9ProtocolTest client with a session. 1580// If additional configuration is needed for the client instance use the optional 1581// aws.Config parameter to add your extra config. 1582// 1583// Example: 1584// // Create a InputService9ProtocolTest client from just a session. 1585// svc := inputservice9protocoltest.New(mySession) 1586// 1587// // Create a InputService9ProtocolTest client with additional configuration 1588// svc := inputservice9protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1589func NewInputService9ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService9ProtocolTest { 1590 c := p.ClientConfig("inputservice9protocoltest", cfgs...) 1591 return newInputService9ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1592} 1593 1594// newClient creates, initializes and returns a new service client instance. 1595func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService9ProtocolTest { 1596 svc := &InputService9ProtocolTest{ 1597 Client: client.New( 1598 cfg, 1599 metadata.ClientInfo{ 1600 ServiceName: "InputService9ProtocolTest", 1601 ServiceID: "InputService9ProtocolTest", 1602 SigningName: signingName, 1603 SigningRegion: signingRegion, 1604 Endpoint: endpoint, 1605 APIVersion: "2014-01-01", 1606 }, 1607 handlers, 1608 ), 1609 } 1610 1611 // Handlers 1612 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1613 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1614 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1615 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1616 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1617 1618 return svc 1619} 1620 1621// newRequest creates a new request for a InputService9ProtocolTest operation and runs any 1622// custom request initialization. 1623func (c *InputService9ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1624 req := c.NewRequest(op, params, data) 1625 1626 return req 1627} 1628 1629const opInputService9TestCaseOperation1 = "OperationName" 1630 1631// InputService9TestCaseOperation1Request generates a "aws/request.Request" representing the 1632// client's request for the InputService9TestCaseOperation1 operation. The "output" return 1633// value will be populated with the request's response once the request completes 1634// successfully. 1635// 1636// Use "Send" method on the returned Request to send the API call to the service. 1637// the "output" return value is not valid until after Send returns without error. 1638// 1639// See InputService9TestCaseOperation1 for more information on using the InputService9TestCaseOperation1 1640// API call, and error handling. 1641// 1642// This method is useful when you want to inject custom logic or configuration 1643// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1644// 1645// 1646// // Example sending a request using the InputService9TestCaseOperation1Request method. 1647// req, resp := client.InputService9TestCaseOperation1Request(params) 1648// 1649// err := req.Send() 1650// if err == nil { // resp is now filled 1651// fmt.Println(resp) 1652// } 1653func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input *InputService9TestShapeInputService9TestCaseOperation1Input) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation1Output) { 1654 op := &request.Operation{ 1655 Name: opInputService9TestCaseOperation1, 1656 HTTPMethod: "POST", 1657 HTTPPath: "/2014-01-01/hostedzone", 1658 } 1659 1660 if input == nil { 1661 input = &InputService9TestShapeInputService9TestCaseOperation1Input{} 1662 } 1663 1664 output = &InputService9TestShapeInputService9TestCaseOperation1Output{} 1665 req = c.newRequest(op, input, output) 1666 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1667 return 1668} 1669 1670// InputService9TestCaseOperation1 API operation for . 1671// 1672// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1673// with awserr.Error's Code and Message methods to get detailed information about 1674// the error. 1675// 1676// See the AWS API reference guide for 's 1677// API operation InputService9TestCaseOperation1 for usage and error information. 1678func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *InputService9TestShapeInputService9TestCaseOperation1Input) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) { 1679 req, out := c.InputService9TestCaseOperation1Request(input) 1680 return out, req.Send() 1681} 1682 1683// InputService9TestCaseOperation1WithContext is the same as InputService9TestCaseOperation1 with the addition of 1684// the ability to pass a context and additional request options. 1685// 1686// See InputService9TestCaseOperation1 for details on how to use this API operation. 1687// 1688// The context must be non-nil and will be used for request cancellation. If 1689// the context is nil a panic will occur. In the future the SDK may create 1690// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1691// for more information on using Contexts. 1692func (c *InputService9ProtocolTest) InputService9TestCaseOperation1WithContext(ctx aws.Context, input *InputService9TestShapeInputService9TestCaseOperation1Input, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) { 1693 req, out := c.InputService9TestCaseOperation1Request(input) 1694 req.SetContext(ctx) 1695 req.ApplyOptions(opts...) 1696 return out, req.Send() 1697} 1698 1699type InputService9TestShapeInputService9TestCaseOperation1Input struct { 1700 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 1701 1702 ListParam []*InputService9TestShapeSingleFieldStruct `locationName:"item" type:"list" flattened:"true"` 1703} 1704 1705// SetListParam sets the ListParam field's value. 1706func (s *InputService9TestShapeInputService9TestCaseOperation1Input) SetListParam(v []*InputService9TestShapeSingleFieldStruct) *InputService9TestShapeInputService9TestCaseOperation1Input { 1707 s.ListParam = v 1708 return s 1709} 1710 1711type InputService9TestShapeInputService9TestCaseOperation1Output struct { 1712 _ struct{} `type:"structure"` 1713} 1714 1715type InputService9TestShapeSingleFieldStruct struct { 1716 _ struct{} `type:"structure"` 1717 1718 Element *string `locationName:"value" type:"string"` 1719} 1720 1721// SetElement sets the Element field's value. 1722func (s *InputService9TestShapeSingleFieldStruct) SetElement(v string) *InputService9TestShapeSingleFieldStruct { 1723 s.Element = &v 1724 return s 1725} 1726 1727// InputService10ProtocolTest provides the API operation methods for making requests to 1728// . See this package's package overview docs 1729// for details on the service. 1730// 1731// InputService10ProtocolTest methods are safe to use concurrently. It is not safe to 1732// modify mutate any of the struct's properties though. 1733type InputService10ProtocolTest struct { 1734 *client.Client 1735} 1736 1737// New creates a new instance of the InputService10ProtocolTest client with a session. 1738// If additional configuration is needed for the client instance use the optional 1739// aws.Config parameter to add your extra config. 1740// 1741// Example: 1742// // Create a InputService10ProtocolTest client from just a session. 1743// svc := inputservice10protocoltest.New(mySession) 1744// 1745// // Create a InputService10ProtocolTest client with additional configuration 1746// svc := inputservice10protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1747func NewInputService10ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService10ProtocolTest { 1748 c := p.ClientConfig("inputservice10protocoltest", cfgs...) 1749 return newInputService10ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1750} 1751 1752// newClient creates, initializes and returns a new service client instance. 1753func newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService10ProtocolTest { 1754 svc := &InputService10ProtocolTest{ 1755 Client: client.New( 1756 cfg, 1757 metadata.ClientInfo{ 1758 ServiceName: "InputService10ProtocolTest", 1759 ServiceID: "InputService10ProtocolTest", 1760 SigningName: signingName, 1761 SigningRegion: signingRegion, 1762 Endpoint: endpoint, 1763 APIVersion: "2014-01-01", 1764 }, 1765 handlers, 1766 ), 1767 } 1768 1769 // Handlers 1770 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1771 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1772 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1773 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1774 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1775 1776 return svc 1777} 1778 1779// newRequest creates a new request for a InputService10ProtocolTest operation and runs any 1780// custom request initialization. 1781func (c *InputService10ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1782 req := c.NewRequest(op, params, data) 1783 1784 return req 1785} 1786 1787const opInputService10TestCaseOperation1 = "OperationName" 1788 1789// InputService10TestCaseOperation1Request generates a "aws/request.Request" representing the 1790// client's request for the InputService10TestCaseOperation1 operation. The "output" return 1791// value will be populated with the request's response once the request completes 1792// successfully. 1793// 1794// Use "Send" method on the returned Request to send the API call to the service. 1795// the "output" return value is not valid until after Send returns without error. 1796// 1797// See InputService10TestCaseOperation1 for more information on using the InputService10TestCaseOperation1 1798// API call, and error handling. 1799// 1800// This method is useful when you want to inject custom logic or configuration 1801// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1802// 1803// 1804// // Example sending a request using the InputService10TestCaseOperation1Request method. 1805// req, resp := client.InputService10TestCaseOperation1Request(params) 1806// 1807// err := req.Send() 1808// if err == nil { // resp is now filled 1809// fmt.Println(resp) 1810// } 1811func (c *InputService10ProtocolTest) InputService10TestCaseOperation1Request(input *InputService10TestShapeInputService10TestCaseOperation1Input) (req *request.Request, output *InputService10TestShapeInputService10TestCaseOperation1Output) { 1812 op := &request.Operation{ 1813 Name: opInputService10TestCaseOperation1, 1814 HTTPMethod: "POST", 1815 HTTPPath: "/2014-01-01/hostedzone", 1816 } 1817 1818 if input == nil { 1819 input = &InputService10TestShapeInputService10TestCaseOperation1Input{} 1820 } 1821 1822 output = &InputService10TestShapeInputService10TestCaseOperation1Output{} 1823 req = c.newRequest(op, input, output) 1824 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1825 return 1826} 1827 1828// InputService10TestCaseOperation1 API operation for . 1829// 1830// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1831// with awserr.Error's Code and Message methods to get detailed information about 1832// the error. 1833// 1834// See the AWS API reference guide for 's 1835// API operation InputService10TestCaseOperation1 for usage and error information. 1836func (c *InputService10ProtocolTest) InputService10TestCaseOperation1(input *InputService10TestShapeInputService10TestCaseOperation1Input) (*InputService10TestShapeInputService10TestCaseOperation1Output, error) { 1837 req, out := c.InputService10TestCaseOperation1Request(input) 1838 return out, req.Send() 1839} 1840 1841// InputService10TestCaseOperation1WithContext is the same as InputService10TestCaseOperation1 with the addition of 1842// the ability to pass a context and additional request options. 1843// 1844// See InputService10TestCaseOperation1 for details on how to use this API operation. 1845// 1846// The context must be non-nil and will be used for request cancellation. If 1847// the context is nil a panic will occur. In the future the SDK may create 1848// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1849// for more information on using Contexts. 1850func (c *InputService10ProtocolTest) InputService10TestCaseOperation1WithContext(ctx aws.Context, input *InputService10TestShapeInputService10TestCaseOperation1Input, opts ...request.Option) (*InputService10TestShapeInputService10TestCaseOperation1Output, error) { 1851 req, out := c.InputService10TestCaseOperation1Request(input) 1852 req.SetContext(ctx) 1853 req.ApplyOptions(opts...) 1854 return out, req.Send() 1855} 1856 1857type InputService10TestShapeInputService10TestCaseOperation1Input struct { 1858 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 1859 1860 StructureParam *InputService10TestShapeStructureShape `type:"structure"` 1861} 1862 1863// SetStructureParam sets the StructureParam field's value. 1864func (s *InputService10TestShapeInputService10TestCaseOperation1Input) SetStructureParam(v *InputService10TestShapeStructureShape) *InputService10TestShapeInputService10TestCaseOperation1Input { 1865 s.StructureParam = v 1866 return s 1867} 1868 1869type InputService10TestShapeInputService10TestCaseOperation1Output struct { 1870 _ struct{} `type:"structure"` 1871} 1872 1873type InputService10TestShapeStructureShape struct { 1874 _ struct{} `type:"structure"` 1875 1876 // B is automatically base64 encoded/decoded by the SDK. 1877 B []byte `locationName:"b" type:"blob"` 1878} 1879 1880// SetB sets the B field's value. 1881func (s *InputService10TestShapeStructureShape) SetB(v []byte) *InputService10TestShapeStructureShape { 1882 s.B = v 1883 return s 1884} 1885 1886// InputService11ProtocolTest provides the API operation methods for making requests to 1887// . See this package's package overview docs 1888// for details on the service. 1889// 1890// InputService11ProtocolTest methods are safe to use concurrently. It is not safe to 1891// modify mutate any of the struct's properties though. 1892type InputService11ProtocolTest struct { 1893 *client.Client 1894} 1895 1896// New creates a new instance of the InputService11ProtocolTest client with a session. 1897// If additional configuration is needed for the client instance use the optional 1898// aws.Config parameter to add your extra config. 1899// 1900// Example: 1901// // Create a InputService11ProtocolTest client from just a session. 1902// svc := inputservice11protocoltest.New(mySession) 1903// 1904// // Create a InputService11ProtocolTest client with additional configuration 1905// svc := inputservice11protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1906func NewInputService11ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService11ProtocolTest { 1907 c := p.ClientConfig("inputservice11protocoltest", cfgs...) 1908 return newInputService11ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1909} 1910 1911// newClient creates, initializes and returns a new service client instance. 1912func newInputService11ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService11ProtocolTest { 1913 svc := &InputService11ProtocolTest{ 1914 Client: client.New( 1915 cfg, 1916 metadata.ClientInfo{ 1917 ServiceName: "InputService11ProtocolTest", 1918 ServiceID: "InputService11ProtocolTest", 1919 SigningName: signingName, 1920 SigningRegion: signingRegion, 1921 Endpoint: endpoint, 1922 APIVersion: "2014-01-01", 1923 }, 1924 handlers, 1925 ), 1926 } 1927 1928 // Handlers 1929 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1930 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1931 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1932 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1933 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1934 1935 return svc 1936} 1937 1938// newRequest creates a new request for a InputService11ProtocolTest operation and runs any 1939// custom request initialization. 1940func (c *InputService11ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1941 req := c.NewRequest(op, params, data) 1942 1943 return req 1944} 1945 1946const opInputService11TestCaseOperation1 = "OperationName" 1947 1948// InputService11TestCaseOperation1Request generates a "aws/request.Request" representing the 1949// client's request for the InputService11TestCaseOperation1 operation. The "output" return 1950// value will be populated with the request's response once the request completes 1951// successfully. 1952// 1953// Use "Send" method on the returned Request to send the API call to the service. 1954// the "output" return value is not valid until after Send returns without error. 1955// 1956// See InputService11TestCaseOperation1 for more information on using the InputService11TestCaseOperation1 1957// API call, and error handling. 1958// 1959// This method is useful when you want to inject custom logic or configuration 1960// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1961// 1962// 1963// // Example sending a request using the InputService11TestCaseOperation1Request method. 1964// req, resp := client.InputService11TestCaseOperation1Request(params) 1965// 1966// err := req.Send() 1967// if err == nil { // resp is now filled 1968// fmt.Println(resp) 1969// } 1970func (c *InputService11ProtocolTest) InputService11TestCaseOperation1Request(input *InputService11TestShapeInputService11TestCaseOperation1Input) (req *request.Request, output *InputService11TestShapeInputService11TestCaseOperation1Output) { 1971 op := &request.Operation{ 1972 Name: opInputService11TestCaseOperation1, 1973 HTTPMethod: "POST", 1974 HTTPPath: "/2014-01-01/hostedzone", 1975 } 1976 1977 if input == nil { 1978 input = &InputService11TestShapeInputService11TestCaseOperation1Input{} 1979 } 1980 1981 output = &InputService11TestShapeInputService11TestCaseOperation1Output{} 1982 req = c.newRequest(op, input, output) 1983 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1984 return 1985} 1986 1987// InputService11TestCaseOperation1 API operation for . 1988// 1989// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1990// with awserr.Error's Code and Message methods to get detailed information about 1991// the error. 1992// 1993// See the AWS API reference guide for 's 1994// API operation InputService11TestCaseOperation1 for usage and error information. 1995func (c *InputService11ProtocolTest) InputService11TestCaseOperation1(input *InputService11TestShapeInputService11TestCaseOperation1Input) (*InputService11TestShapeInputService11TestCaseOperation1Output, error) { 1996 req, out := c.InputService11TestCaseOperation1Request(input) 1997 return out, req.Send() 1998} 1999 2000// InputService11TestCaseOperation1WithContext is the same as InputService11TestCaseOperation1 with the addition of 2001// the ability to pass a context and additional request options. 2002// 2003// See InputService11TestCaseOperation1 for details on how to use this API operation. 2004// 2005// The context must be non-nil and will be used for request cancellation. If 2006// the context is nil a panic will occur. In the future the SDK may create 2007// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2008// for more information on using Contexts. 2009func (c *InputService11ProtocolTest) InputService11TestCaseOperation1WithContext(ctx aws.Context, input *InputService11TestShapeInputService11TestCaseOperation1Input, opts ...request.Option) (*InputService11TestShapeInputService11TestCaseOperation1Output, error) { 2010 req, out := c.InputService11TestCaseOperation1Request(input) 2011 req.SetContext(ctx) 2012 req.ApplyOptions(opts...) 2013 return out, req.Send() 2014} 2015 2016type InputService11TestShapeInputService11TestCaseOperation1Input struct { 2017 _ struct{} `locationName:"TimestampStructure" type:"structure" xmlURI:"https://foo/"` 2018 2019 TimeArg *time.Time `type:"timestamp"` 2020 2021 TimeArgInHeader *time.Time `location:"header" locationName:"x-amz-timearg" type:"timestamp"` 2022 2023 TimeArgInQuery *time.Time `location:"querystring" locationName:"TimeQuery" type:"timestamp"` 2024 2025 TimeCustom *time.Time `type:"timestamp" timestampFormat:"rfc822"` 2026 2027 TimeCustomInHeader *time.Time `location:"header" locationName:"x-amz-timecustom-header" type:"timestamp" timestampFormat:"unixTimestamp"` 2028 2029 TimeCustomInQuery *time.Time `location:"querystring" locationName:"TimeCustomQuery" type:"timestamp" timestampFormat:"unixTimestamp"` 2030 2031 TimeFormat *time.Time `type:"timestamp" timestampFormat:"rfc822"` 2032 2033 TimeFormatInHeader *time.Time `location:"header" locationName:"x-amz-timeformat-header" type:"timestamp" timestampFormat:"unixTimestamp"` 2034 2035 TimeFormatInQuery *time.Time `location:"querystring" locationName:"TimeFormatQuery" type:"timestamp" timestampFormat:"unixTimestamp"` 2036} 2037 2038// SetTimeArg sets the TimeArg field's value. 2039func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeArg(v time.Time) *InputService11TestShapeInputService11TestCaseOperation1Input { 2040 s.TimeArg = &v 2041 return s 2042} 2043 2044// SetTimeArgInHeader sets the TimeArgInHeader field's value. 2045func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeArgInHeader(v time.Time) *InputService11TestShapeInputService11TestCaseOperation1Input { 2046 s.TimeArgInHeader = &v 2047 return s 2048} 2049 2050// SetTimeArgInQuery sets the TimeArgInQuery field's value. 2051func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeArgInQuery(v time.Time) *InputService11TestShapeInputService11TestCaseOperation1Input { 2052 s.TimeArgInQuery = &v 2053 return s 2054} 2055 2056// SetTimeCustom sets the TimeCustom field's value. 2057func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeCustom(v time.Time) *InputService11TestShapeInputService11TestCaseOperation1Input { 2058 s.TimeCustom = &v 2059 return s 2060} 2061 2062// SetTimeCustomInHeader sets the TimeCustomInHeader field's value. 2063func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeCustomInHeader(v time.Time) *InputService11TestShapeInputService11TestCaseOperation1Input { 2064 s.TimeCustomInHeader = &v 2065 return s 2066} 2067 2068// SetTimeCustomInQuery sets the TimeCustomInQuery field's value. 2069func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeCustomInQuery(v time.Time) *InputService11TestShapeInputService11TestCaseOperation1Input { 2070 s.TimeCustomInQuery = &v 2071 return s 2072} 2073 2074// SetTimeFormat sets the TimeFormat field's value. 2075func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeFormat(v time.Time) *InputService11TestShapeInputService11TestCaseOperation1Input { 2076 s.TimeFormat = &v 2077 return s 2078} 2079 2080// SetTimeFormatInHeader sets the TimeFormatInHeader field's value. 2081func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeFormatInHeader(v time.Time) *InputService11TestShapeInputService11TestCaseOperation1Input { 2082 s.TimeFormatInHeader = &v 2083 return s 2084} 2085 2086// SetTimeFormatInQuery sets the TimeFormatInQuery field's value. 2087func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetTimeFormatInQuery(v time.Time) *InputService11TestShapeInputService11TestCaseOperation1Input { 2088 s.TimeFormatInQuery = &v 2089 return s 2090} 2091 2092type InputService11TestShapeInputService11TestCaseOperation1Output struct { 2093 _ struct{} `type:"structure"` 2094} 2095 2096// InputService12ProtocolTest provides the API operation methods for making requests to 2097// . See this package's package overview docs 2098// for details on the service. 2099// 2100// InputService12ProtocolTest methods are safe to use concurrently. It is not safe to 2101// modify mutate any of the struct's properties though. 2102type InputService12ProtocolTest struct { 2103 *client.Client 2104} 2105 2106// New creates a new instance of the InputService12ProtocolTest client with a session. 2107// If additional configuration is needed for the client instance use the optional 2108// aws.Config parameter to add your extra config. 2109// 2110// Example: 2111// // Create a InputService12ProtocolTest client from just a session. 2112// svc := inputservice12protocoltest.New(mySession) 2113// 2114// // Create a InputService12ProtocolTest client with additional configuration 2115// svc := inputservice12protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2116func NewInputService12ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService12ProtocolTest { 2117 c := p.ClientConfig("inputservice12protocoltest", cfgs...) 2118 return newInputService12ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2119} 2120 2121// newClient creates, initializes and returns a new service client instance. 2122func newInputService12ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService12ProtocolTest { 2123 svc := &InputService12ProtocolTest{ 2124 Client: client.New( 2125 cfg, 2126 metadata.ClientInfo{ 2127 ServiceName: "InputService12ProtocolTest", 2128 ServiceID: "InputService12ProtocolTest", 2129 SigningName: signingName, 2130 SigningRegion: signingRegion, 2131 Endpoint: endpoint, 2132 APIVersion: "2014-01-01", 2133 }, 2134 handlers, 2135 ), 2136 } 2137 2138 // Handlers 2139 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2140 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 2141 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 2142 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 2143 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 2144 2145 return svc 2146} 2147 2148// newRequest creates a new request for a InputService12ProtocolTest operation and runs any 2149// custom request initialization. 2150func (c *InputService12ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2151 req := c.NewRequest(op, params, data) 2152 2153 return req 2154} 2155 2156const opInputService12TestCaseOperation1 = "OperationName" 2157 2158// InputService12TestCaseOperation1Request generates a "aws/request.Request" representing the 2159// client's request for the InputService12TestCaseOperation1 operation. The "output" return 2160// value will be populated with the request's response once the request completes 2161// successfully. 2162// 2163// Use "Send" method on the returned Request to send the API call to the service. 2164// the "output" return value is not valid until after Send returns without error. 2165// 2166// See InputService12TestCaseOperation1 for more information on using the InputService12TestCaseOperation1 2167// API call, and error handling. 2168// 2169// This method is useful when you want to inject custom logic or configuration 2170// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2171// 2172// 2173// // Example sending a request using the InputService12TestCaseOperation1Request method. 2174// req, resp := client.InputService12TestCaseOperation1Request(params) 2175// 2176// err := req.Send() 2177// if err == nil { // resp is now filled 2178// fmt.Println(resp) 2179// } 2180func (c *InputService12ProtocolTest) InputService12TestCaseOperation1Request(input *InputService12TestShapeInputService12TestCaseOperation1Input) (req *request.Request, output *InputService12TestShapeInputService12TestCaseOperation1Output) { 2181 op := &request.Operation{ 2182 Name: opInputService12TestCaseOperation1, 2183 HTTPMethod: "POST", 2184 HTTPPath: "/", 2185 } 2186 2187 if input == nil { 2188 input = &InputService12TestShapeInputService12TestCaseOperation1Input{} 2189 } 2190 2191 output = &InputService12TestShapeInputService12TestCaseOperation1Output{} 2192 req = c.newRequest(op, input, output) 2193 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2194 return 2195} 2196 2197// InputService12TestCaseOperation1 API operation for . 2198// 2199// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2200// with awserr.Error's Code and Message methods to get detailed information about 2201// the error. 2202// 2203// See the AWS API reference guide for 's 2204// API operation InputService12TestCaseOperation1 for usage and error information. 2205func (c *InputService12ProtocolTest) InputService12TestCaseOperation1(input *InputService12TestShapeInputService12TestCaseOperation1Input) (*InputService12TestShapeInputService12TestCaseOperation1Output, error) { 2206 req, out := c.InputService12TestCaseOperation1Request(input) 2207 return out, req.Send() 2208} 2209 2210// InputService12TestCaseOperation1WithContext is the same as InputService12TestCaseOperation1 with the addition of 2211// the ability to pass a context and additional request options. 2212// 2213// See InputService12TestCaseOperation1 for details on how to use this API operation. 2214// 2215// The context must be non-nil and will be used for request cancellation. If 2216// the context is nil a panic will occur. In the future the SDK may create 2217// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2218// for more information on using Contexts. 2219func (c *InputService12ProtocolTest) InputService12TestCaseOperation1WithContext(ctx aws.Context, input *InputService12TestShapeInputService12TestCaseOperation1Input, opts ...request.Option) (*InputService12TestShapeInputService12TestCaseOperation1Output, error) { 2220 req, out := c.InputService12TestCaseOperation1Request(input) 2221 req.SetContext(ctx) 2222 req.ApplyOptions(opts...) 2223 return out, req.Send() 2224} 2225 2226type InputService12TestShapeInputService12TestCaseOperation1Input struct { 2227 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 2228 2229 Foo map[string]*string `location:"headers" locationName:"x-foo-" type:"map"` 2230} 2231 2232// SetFoo sets the Foo field's value. 2233func (s *InputService12TestShapeInputService12TestCaseOperation1Input) SetFoo(v map[string]*string) *InputService12TestShapeInputService12TestCaseOperation1Input { 2234 s.Foo = v 2235 return s 2236} 2237 2238type InputService12TestShapeInputService12TestCaseOperation1Output struct { 2239 _ struct{} `type:"structure"` 2240} 2241 2242// InputService13ProtocolTest provides the API operation methods for making requests to 2243// . See this package's package overview docs 2244// for details on the service. 2245// 2246// InputService13ProtocolTest methods are safe to use concurrently. It is not safe to 2247// modify mutate any of the struct's properties though. 2248type InputService13ProtocolTest struct { 2249 *client.Client 2250} 2251 2252// New creates a new instance of the InputService13ProtocolTest client with a session. 2253// If additional configuration is needed for the client instance use the optional 2254// aws.Config parameter to add your extra config. 2255// 2256// Example: 2257// // Create a InputService13ProtocolTest client from just a session. 2258// svc := inputservice13protocoltest.New(mySession) 2259// 2260// // Create a InputService13ProtocolTest client with additional configuration 2261// svc := inputservice13protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2262func NewInputService13ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService13ProtocolTest { 2263 c := p.ClientConfig("inputservice13protocoltest", cfgs...) 2264 return newInputService13ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2265} 2266 2267// newClient creates, initializes and returns a new service client instance. 2268func newInputService13ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService13ProtocolTest { 2269 svc := &InputService13ProtocolTest{ 2270 Client: client.New( 2271 cfg, 2272 metadata.ClientInfo{ 2273 ServiceName: "InputService13ProtocolTest", 2274 ServiceID: "InputService13ProtocolTest", 2275 SigningName: signingName, 2276 SigningRegion: signingRegion, 2277 Endpoint: endpoint, 2278 APIVersion: "2014-01-01", 2279 }, 2280 handlers, 2281 ), 2282 } 2283 2284 // Handlers 2285 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2286 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 2287 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 2288 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 2289 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 2290 2291 return svc 2292} 2293 2294// newRequest creates a new request for a InputService13ProtocolTest operation and runs any 2295// custom request initialization. 2296func (c *InputService13ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2297 req := c.NewRequest(op, params, data) 2298 2299 return req 2300} 2301 2302const opInputService13TestCaseOperation1 = "OperationName" 2303 2304// InputService13TestCaseOperation1Request generates a "aws/request.Request" representing the 2305// client's request for the InputService13TestCaseOperation1 operation. The "output" return 2306// value will be populated with the request's response once the request completes 2307// successfully. 2308// 2309// Use "Send" method on the returned Request to send the API call to the service. 2310// the "output" return value is not valid until after Send returns without error. 2311// 2312// See InputService13TestCaseOperation1 for more information on using the InputService13TestCaseOperation1 2313// API call, and error handling. 2314// 2315// This method is useful when you want to inject custom logic or configuration 2316// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2317// 2318// 2319// // Example sending a request using the InputService13TestCaseOperation1Request method. 2320// req, resp := client.InputService13TestCaseOperation1Request(params) 2321// 2322// err := req.Send() 2323// if err == nil { // resp is now filled 2324// fmt.Println(resp) 2325// } 2326func (c *InputService13ProtocolTest) InputService13TestCaseOperation1Request(input *InputService13TestShapeInputService13TestCaseOperation1Input) (req *request.Request, output *InputService13TestShapeInputService13TestCaseOperation1Output) { 2327 op := &request.Operation{ 2328 Name: opInputService13TestCaseOperation1, 2329 HTTPMethod: "GET", 2330 HTTPPath: "/path", 2331 } 2332 2333 if input == nil { 2334 input = &InputService13TestShapeInputService13TestCaseOperation1Input{} 2335 } 2336 2337 output = &InputService13TestShapeInputService13TestCaseOperation1Output{} 2338 req = c.newRequest(op, input, output) 2339 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2340 return 2341} 2342 2343// InputService13TestCaseOperation1 API operation for . 2344// 2345// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2346// with awserr.Error's Code and Message methods to get detailed information about 2347// the error. 2348// 2349// See the AWS API reference guide for 's 2350// API operation InputService13TestCaseOperation1 for usage and error information. 2351func (c *InputService13ProtocolTest) InputService13TestCaseOperation1(input *InputService13TestShapeInputService13TestCaseOperation1Input) (*InputService13TestShapeInputService13TestCaseOperation1Output, error) { 2352 req, out := c.InputService13TestCaseOperation1Request(input) 2353 return out, req.Send() 2354} 2355 2356// InputService13TestCaseOperation1WithContext is the same as InputService13TestCaseOperation1 with the addition of 2357// the ability to pass a context and additional request options. 2358// 2359// See InputService13TestCaseOperation1 for details on how to use this API operation. 2360// 2361// The context must be non-nil and will be used for request cancellation. If 2362// the context is nil a panic will occur. In the future the SDK may create 2363// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2364// for more information on using Contexts. 2365func (c *InputService13ProtocolTest) InputService13TestCaseOperation1WithContext(ctx aws.Context, input *InputService13TestShapeInputService13TestCaseOperation1Input, opts ...request.Option) (*InputService13TestShapeInputService13TestCaseOperation1Output, error) { 2366 req, out := c.InputService13TestCaseOperation1Request(input) 2367 req.SetContext(ctx) 2368 req.ApplyOptions(opts...) 2369 return out, req.Send() 2370} 2371 2372type InputService13TestShapeInputService13TestCaseOperation1Input struct { 2373 _ struct{} `type:"structure"` 2374 2375 Items []*string `location:"querystring" locationName:"item" type:"list"` 2376} 2377 2378// SetItems sets the Items field's value. 2379func (s *InputService13TestShapeInputService13TestCaseOperation1Input) SetItems(v []*string) *InputService13TestShapeInputService13TestCaseOperation1Input { 2380 s.Items = v 2381 return s 2382} 2383 2384type InputService13TestShapeInputService13TestCaseOperation1Output struct { 2385 _ struct{} `type:"structure"` 2386} 2387 2388// InputService14ProtocolTest provides the API operation methods for making requests to 2389// . See this package's package overview docs 2390// for details on the service. 2391// 2392// InputService14ProtocolTest methods are safe to use concurrently. It is not safe to 2393// modify mutate any of the struct's properties though. 2394type InputService14ProtocolTest struct { 2395 *client.Client 2396} 2397 2398// New creates a new instance of the InputService14ProtocolTest client with a session. 2399// If additional configuration is needed for the client instance use the optional 2400// aws.Config parameter to add your extra config. 2401// 2402// Example: 2403// // Create a InputService14ProtocolTest client from just a session. 2404// svc := inputservice14protocoltest.New(mySession) 2405// 2406// // Create a InputService14ProtocolTest client with additional configuration 2407// svc := inputservice14protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2408func NewInputService14ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService14ProtocolTest { 2409 c := p.ClientConfig("inputservice14protocoltest", cfgs...) 2410 return newInputService14ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2411} 2412 2413// newClient creates, initializes and returns a new service client instance. 2414func newInputService14ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService14ProtocolTest { 2415 svc := &InputService14ProtocolTest{ 2416 Client: client.New( 2417 cfg, 2418 metadata.ClientInfo{ 2419 ServiceName: "InputService14ProtocolTest", 2420 ServiceID: "InputService14ProtocolTest", 2421 SigningName: signingName, 2422 SigningRegion: signingRegion, 2423 Endpoint: endpoint, 2424 APIVersion: "2014-01-01", 2425 }, 2426 handlers, 2427 ), 2428 } 2429 2430 // Handlers 2431 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2432 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 2433 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 2434 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 2435 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 2436 2437 return svc 2438} 2439 2440// newRequest creates a new request for a InputService14ProtocolTest operation and runs any 2441// custom request initialization. 2442func (c *InputService14ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2443 req := c.NewRequest(op, params, data) 2444 2445 return req 2446} 2447 2448const opInputService14TestCaseOperation1 = "OperationName" 2449 2450// InputService14TestCaseOperation1Request generates a "aws/request.Request" representing the 2451// client's request for the InputService14TestCaseOperation1 operation. The "output" return 2452// value will be populated with the request's response once the request completes 2453// successfully. 2454// 2455// Use "Send" method on the returned Request to send the API call to the service. 2456// the "output" return value is not valid until after Send returns without error. 2457// 2458// See InputService14TestCaseOperation1 for more information on using the InputService14TestCaseOperation1 2459// API call, and error handling. 2460// 2461// This method is useful when you want to inject custom logic or configuration 2462// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2463// 2464// 2465// // Example sending a request using the InputService14TestCaseOperation1Request method. 2466// req, resp := client.InputService14TestCaseOperation1Request(params) 2467// 2468// err := req.Send() 2469// if err == nil { // resp is now filled 2470// fmt.Println(resp) 2471// } 2472func (c *InputService14ProtocolTest) InputService14TestCaseOperation1Request(input *InputService14TestShapeInputService14TestCaseOperation1Input) (req *request.Request, output *InputService14TestShapeInputService14TestCaseOperation1Output) { 2473 op := &request.Operation{ 2474 Name: opInputService14TestCaseOperation1, 2475 HTTPMethod: "GET", 2476 HTTPPath: "/2014-01-01/jobsByPipeline/{PipelineId}", 2477 } 2478 2479 if input == nil { 2480 input = &InputService14TestShapeInputService14TestCaseOperation1Input{} 2481 } 2482 2483 output = &InputService14TestShapeInputService14TestCaseOperation1Output{} 2484 req = c.newRequest(op, input, output) 2485 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2486 return 2487} 2488 2489// InputService14TestCaseOperation1 API operation for . 2490// 2491// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2492// with awserr.Error's Code and Message methods to get detailed information about 2493// the error. 2494// 2495// See the AWS API reference guide for 's 2496// API operation InputService14TestCaseOperation1 for usage and error information. 2497func (c *InputService14ProtocolTest) InputService14TestCaseOperation1(input *InputService14TestShapeInputService14TestCaseOperation1Input) (*InputService14TestShapeInputService14TestCaseOperation1Output, error) { 2498 req, out := c.InputService14TestCaseOperation1Request(input) 2499 return out, req.Send() 2500} 2501 2502// InputService14TestCaseOperation1WithContext is the same as InputService14TestCaseOperation1 with the addition of 2503// the ability to pass a context and additional request options. 2504// 2505// See InputService14TestCaseOperation1 for details on how to use this API operation. 2506// 2507// The context must be non-nil and will be used for request cancellation. If 2508// the context is nil a panic will occur. In the future the SDK may create 2509// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2510// for more information on using Contexts. 2511func (c *InputService14ProtocolTest) InputService14TestCaseOperation1WithContext(ctx aws.Context, input *InputService14TestShapeInputService14TestCaseOperation1Input, opts ...request.Option) (*InputService14TestShapeInputService14TestCaseOperation1Output, error) { 2512 req, out := c.InputService14TestCaseOperation1Request(input) 2513 req.SetContext(ctx) 2514 req.ApplyOptions(opts...) 2515 return out, req.Send() 2516} 2517 2518type InputService14TestShapeInputService14TestCaseOperation1Input struct { 2519 _ struct{} `type:"structure"` 2520 2521 // PipelineId is a required field 2522 PipelineId *string `location:"uri" type:"string" required:"true"` 2523 2524 QueryDoc map[string]*string `location:"querystring" type:"map"` 2525} 2526 2527// Validate inspects the fields of the type to determine if they are valid. 2528func (s *InputService14TestShapeInputService14TestCaseOperation1Input) Validate() error { 2529 invalidParams := request.ErrInvalidParams{Context: "InputService14TestShapeInputService14TestCaseOperation1Input"} 2530 if s.PipelineId == nil { 2531 invalidParams.Add(request.NewErrParamRequired("PipelineId")) 2532 } 2533 if s.PipelineId != nil && len(*s.PipelineId) < 1 { 2534 invalidParams.Add(request.NewErrParamMinLen("PipelineId", 1)) 2535 } 2536 2537 if invalidParams.Len() > 0 { 2538 return invalidParams 2539 } 2540 return nil 2541} 2542 2543// SetPipelineId sets the PipelineId field's value. 2544func (s *InputService14TestShapeInputService14TestCaseOperation1Input) SetPipelineId(v string) *InputService14TestShapeInputService14TestCaseOperation1Input { 2545 s.PipelineId = &v 2546 return s 2547} 2548 2549// SetQueryDoc sets the QueryDoc field's value. 2550func (s *InputService14TestShapeInputService14TestCaseOperation1Input) SetQueryDoc(v map[string]*string) *InputService14TestShapeInputService14TestCaseOperation1Input { 2551 s.QueryDoc = v 2552 return s 2553} 2554 2555type InputService14TestShapeInputService14TestCaseOperation1Output struct { 2556 _ struct{} `type:"structure"` 2557} 2558 2559// InputService15ProtocolTest provides the API operation methods for making requests to 2560// . See this package's package overview docs 2561// for details on the service. 2562// 2563// InputService15ProtocolTest methods are safe to use concurrently. It is not safe to 2564// modify mutate any of the struct's properties though. 2565type InputService15ProtocolTest struct { 2566 *client.Client 2567} 2568 2569// New creates a new instance of the InputService15ProtocolTest client with a session. 2570// If additional configuration is needed for the client instance use the optional 2571// aws.Config parameter to add your extra config. 2572// 2573// Example: 2574// // Create a InputService15ProtocolTest client from just a session. 2575// svc := inputservice15protocoltest.New(mySession) 2576// 2577// // Create a InputService15ProtocolTest client with additional configuration 2578// svc := inputservice15protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2579func NewInputService15ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService15ProtocolTest { 2580 c := p.ClientConfig("inputservice15protocoltest", cfgs...) 2581 return newInputService15ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2582} 2583 2584// newClient creates, initializes and returns a new service client instance. 2585func newInputService15ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService15ProtocolTest { 2586 svc := &InputService15ProtocolTest{ 2587 Client: client.New( 2588 cfg, 2589 metadata.ClientInfo{ 2590 ServiceName: "InputService15ProtocolTest", 2591 ServiceID: "InputService15ProtocolTest", 2592 SigningName: signingName, 2593 SigningRegion: signingRegion, 2594 Endpoint: endpoint, 2595 APIVersion: "2014-01-01", 2596 }, 2597 handlers, 2598 ), 2599 } 2600 2601 // Handlers 2602 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2603 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 2604 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 2605 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 2606 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 2607 2608 return svc 2609} 2610 2611// newRequest creates a new request for a InputService15ProtocolTest operation and runs any 2612// custom request initialization. 2613func (c *InputService15ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2614 req := c.NewRequest(op, params, data) 2615 2616 return req 2617} 2618 2619const opInputService15TestCaseOperation1 = "OperationName" 2620 2621// InputService15TestCaseOperation1Request generates a "aws/request.Request" representing the 2622// client's request for the InputService15TestCaseOperation1 operation. The "output" return 2623// value will be populated with the request's response once the request completes 2624// successfully. 2625// 2626// Use "Send" method on the returned Request to send the API call to the service. 2627// the "output" return value is not valid until after Send returns without error. 2628// 2629// See InputService15TestCaseOperation1 for more information on using the InputService15TestCaseOperation1 2630// API call, and error handling. 2631// 2632// This method is useful when you want to inject custom logic or configuration 2633// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2634// 2635// 2636// // Example sending a request using the InputService15TestCaseOperation1Request method. 2637// req, resp := client.InputService15TestCaseOperation1Request(params) 2638// 2639// err := req.Send() 2640// if err == nil { // resp is now filled 2641// fmt.Println(resp) 2642// } 2643func (c *InputService15ProtocolTest) InputService15TestCaseOperation1Request(input *InputService15TestShapeInputService15TestCaseOperation1Input) (req *request.Request, output *InputService15TestShapeInputService15TestCaseOperation1Output) { 2644 op := &request.Operation{ 2645 Name: opInputService15TestCaseOperation1, 2646 HTTPMethod: "GET", 2647 HTTPPath: "/2014-01-01/jobsByPipeline/{PipelineId}", 2648 } 2649 2650 if input == nil { 2651 input = &InputService15TestShapeInputService15TestCaseOperation1Input{} 2652 } 2653 2654 output = &InputService15TestShapeInputService15TestCaseOperation1Output{} 2655 req = c.newRequest(op, input, output) 2656 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2657 return 2658} 2659 2660// InputService15TestCaseOperation1 API operation for . 2661// 2662// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2663// with awserr.Error's Code and Message methods to get detailed information about 2664// the error. 2665// 2666// See the AWS API reference guide for 's 2667// API operation InputService15TestCaseOperation1 for usage and error information. 2668func (c *InputService15ProtocolTest) InputService15TestCaseOperation1(input *InputService15TestShapeInputService15TestCaseOperation1Input) (*InputService15TestShapeInputService15TestCaseOperation1Output, error) { 2669 req, out := c.InputService15TestCaseOperation1Request(input) 2670 return out, req.Send() 2671} 2672 2673// InputService15TestCaseOperation1WithContext is the same as InputService15TestCaseOperation1 with the addition of 2674// the ability to pass a context and additional request options. 2675// 2676// See InputService15TestCaseOperation1 for details on how to use this API operation. 2677// 2678// The context must be non-nil and will be used for request cancellation. If 2679// the context is nil a panic will occur. In the future the SDK may create 2680// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2681// for more information on using Contexts. 2682func (c *InputService15ProtocolTest) InputService15TestCaseOperation1WithContext(ctx aws.Context, input *InputService15TestShapeInputService15TestCaseOperation1Input, opts ...request.Option) (*InputService15TestShapeInputService15TestCaseOperation1Output, error) { 2683 req, out := c.InputService15TestCaseOperation1Request(input) 2684 req.SetContext(ctx) 2685 req.ApplyOptions(opts...) 2686 return out, req.Send() 2687} 2688 2689type InputService15TestShapeInputService15TestCaseOperation1Input struct { 2690 _ struct{} `type:"structure"` 2691 2692 // PipelineId is a required field 2693 PipelineId *string `location:"uri" type:"string" required:"true"` 2694 2695 QueryDoc map[string][]*string `location:"querystring" type:"map"` 2696} 2697 2698// Validate inspects the fields of the type to determine if they are valid. 2699func (s *InputService15TestShapeInputService15TestCaseOperation1Input) Validate() error { 2700 invalidParams := request.ErrInvalidParams{Context: "InputService15TestShapeInputService15TestCaseOperation1Input"} 2701 if s.PipelineId == nil { 2702 invalidParams.Add(request.NewErrParamRequired("PipelineId")) 2703 } 2704 if s.PipelineId != nil && len(*s.PipelineId) < 1 { 2705 invalidParams.Add(request.NewErrParamMinLen("PipelineId", 1)) 2706 } 2707 2708 if invalidParams.Len() > 0 { 2709 return invalidParams 2710 } 2711 return nil 2712} 2713 2714// SetPipelineId sets the PipelineId field's value. 2715func (s *InputService15TestShapeInputService15TestCaseOperation1Input) SetPipelineId(v string) *InputService15TestShapeInputService15TestCaseOperation1Input { 2716 s.PipelineId = &v 2717 return s 2718} 2719 2720// SetQueryDoc sets the QueryDoc field's value. 2721func (s *InputService15TestShapeInputService15TestCaseOperation1Input) SetQueryDoc(v map[string][]*string) *InputService15TestShapeInputService15TestCaseOperation1Input { 2722 s.QueryDoc = v 2723 return s 2724} 2725 2726type InputService15TestShapeInputService15TestCaseOperation1Output struct { 2727 _ struct{} `type:"structure"` 2728} 2729 2730// InputService16ProtocolTest provides the API operation methods for making requests to 2731// . See this package's package overview docs 2732// for details on the service. 2733// 2734// InputService16ProtocolTest methods are safe to use concurrently. It is not safe to 2735// modify mutate any of the struct's properties though. 2736type InputService16ProtocolTest struct { 2737 *client.Client 2738} 2739 2740// New creates a new instance of the InputService16ProtocolTest client with a session. 2741// If additional configuration is needed for the client instance use the optional 2742// aws.Config parameter to add your extra config. 2743// 2744// Example: 2745// // Create a InputService16ProtocolTest client from just a session. 2746// svc := inputservice16protocoltest.New(mySession) 2747// 2748// // Create a InputService16ProtocolTest client with additional configuration 2749// svc := inputservice16protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2750func NewInputService16ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService16ProtocolTest { 2751 c := p.ClientConfig("inputservice16protocoltest", cfgs...) 2752 return newInputService16ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2753} 2754 2755// newClient creates, initializes and returns a new service client instance. 2756func newInputService16ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService16ProtocolTest { 2757 svc := &InputService16ProtocolTest{ 2758 Client: client.New( 2759 cfg, 2760 metadata.ClientInfo{ 2761 ServiceName: "InputService16ProtocolTest", 2762 ServiceID: "InputService16ProtocolTest", 2763 SigningName: signingName, 2764 SigningRegion: signingRegion, 2765 Endpoint: endpoint, 2766 APIVersion: "2014-01-01", 2767 }, 2768 handlers, 2769 ), 2770 } 2771 2772 // Handlers 2773 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2774 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 2775 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 2776 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 2777 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 2778 2779 return svc 2780} 2781 2782// newRequest creates a new request for a InputService16ProtocolTest operation and runs any 2783// custom request initialization. 2784func (c *InputService16ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2785 req := c.NewRequest(op, params, data) 2786 2787 return req 2788} 2789 2790const opInputService16TestCaseOperation1 = "OperationName" 2791 2792// InputService16TestCaseOperation1Request generates a "aws/request.Request" representing the 2793// client's request for the InputService16TestCaseOperation1 operation. The "output" return 2794// value will be populated with the request's response once the request completes 2795// successfully. 2796// 2797// Use "Send" method on the returned Request to send the API call to the service. 2798// the "output" return value is not valid until after Send returns without error. 2799// 2800// See InputService16TestCaseOperation1 for more information on using the InputService16TestCaseOperation1 2801// API call, and error handling. 2802// 2803// This method is useful when you want to inject custom logic or configuration 2804// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2805// 2806// 2807// // Example sending a request using the InputService16TestCaseOperation1Request method. 2808// req, resp := client.InputService16TestCaseOperation1Request(params) 2809// 2810// err := req.Send() 2811// if err == nil { // resp is now filled 2812// fmt.Println(resp) 2813// } 2814func (c *InputService16ProtocolTest) InputService16TestCaseOperation1Request(input *InputService16TestShapeInputService16TestCaseOperation1Input) (req *request.Request, output *InputService16TestShapeInputService16TestCaseOperation1Output) { 2815 op := &request.Operation{ 2816 Name: opInputService16TestCaseOperation1, 2817 HTTPMethod: "GET", 2818 HTTPPath: "/path", 2819 } 2820 2821 if input == nil { 2822 input = &InputService16TestShapeInputService16TestCaseOperation1Input{} 2823 } 2824 2825 output = &InputService16TestShapeInputService16TestCaseOperation1Output{} 2826 req = c.newRequest(op, input, output) 2827 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2828 return 2829} 2830 2831// InputService16TestCaseOperation1 API operation for . 2832// 2833// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2834// with awserr.Error's Code and Message methods to get detailed information about 2835// the error. 2836// 2837// See the AWS API reference guide for 's 2838// API operation InputService16TestCaseOperation1 for usage and error information. 2839func (c *InputService16ProtocolTest) InputService16TestCaseOperation1(input *InputService16TestShapeInputService16TestCaseOperation1Input) (*InputService16TestShapeInputService16TestCaseOperation1Output, error) { 2840 req, out := c.InputService16TestCaseOperation1Request(input) 2841 return out, req.Send() 2842} 2843 2844// InputService16TestCaseOperation1WithContext is the same as InputService16TestCaseOperation1 with the addition of 2845// the ability to pass a context and additional request options. 2846// 2847// See InputService16TestCaseOperation1 for details on how to use this API operation. 2848// 2849// The context must be non-nil and will be used for request cancellation. If 2850// the context is nil a panic will occur. In the future the SDK may create 2851// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2852// for more information on using Contexts. 2853func (c *InputService16ProtocolTest) InputService16TestCaseOperation1WithContext(ctx aws.Context, input *InputService16TestShapeInputService16TestCaseOperation1Input, opts ...request.Option) (*InputService16TestShapeInputService16TestCaseOperation1Output, error) { 2854 req, out := c.InputService16TestCaseOperation1Request(input) 2855 req.SetContext(ctx) 2856 req.ApplyOptions(opts...) 2857 return out, req.Send() 2858} 2859 2860const opInputService16TestCaseOperation2 = "OperationName" 2861 2862// InputService16TestCaseOperation2Request generates a "aws/request.Request" representing the 2863// client's request for the InputService16TestCaseOperation2 operation. The "output" return 2864// value will be populated with the request's response once the request completes 2865// successfully. 2866// 2867// Use "Send" method on the returned Request to send the API call to the service. 2868// the "output" return value is not valid until after Send returns without error. 2869// 2870// See InputService16TestCaseOperation2 for more information on using the InputService16TestCaseOperation2 2871// API call, and error handling. 2872// 2873// This method is useful when you want to inject custom logic or configuration 2874// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2875// 2876// 2877// // Example sending a request using the InputService16TestCaseOperation2Request method. 2878// req, resp := client.InputService16TestCaseOperation2Request(params) 2879// 2880// err := req.Send() 2881// if err == nil { // resp is now filled 2882// fmt.Println(resp) 2883// } 2884func (c *InputService16ProtocolTest) InputService16TestCaseOperation2Request(input *InputService16TestShapeInputService16TestCaseOperation2Input) (req *request.Request, output *InputService16TestShapeInputService16TestCaseOperation2Output) { 2885 op := &request.Operation{ 2886 Name: opInputService16TestCaseOperation2, 2887 HTTPMethod: "GET", 2888 HTTPPath: "/path", 2889 } 2890 2891 if input == nil { 2892 input = &InputService16TestShapeInputService16TestCaseOperation2Input{} 2893 } 2894 2895 output = &InputService16TestShapeInputService16TestCaseOperation2Output{} 2896 req = c.newRequest(op, input, output) 2897 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 2898 return 2899} 2900 2901// InputService16TestCaseOperation2 API operation for . 2902// 2903// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2904// with awserr.Error's Code and Message methods to get detailed information about 2905// the error. 2906// 2907// See the AWS API reference guide for 's 2908// API operation InputService16TestCaseOperation2 for usage and error information. 2909func (c *InputService16ProtocolTest) InputService16TestCaseOperation2(input *InputService16TestShapeInputService16TestCaseOperation2Input) (*InputService16TestShapeInputService16TestCaseOperation2Output, error) { 2910 req, out := c.InputService16TestCaseOperation2Request(input) 2911 return out, req.Send() 2912} 2913 2914// InputService16TestCaseOperation2WithContext is the same as InputService16TestCaseOperation2 with the addition of 2915// the ability to pass a context and additional request options. 2916// 2917// See InputService16TestCaseOperation2 for details on how to use this API operation. 2918// 2919// The context must be non-nil and will be used for request cancellation. If 2920// the context is nil a panic will occur. In the future the SDK may create 2921// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2922// for more information on using Contexts. 2923func (c *InputService16ProtocolTest) InputService16TestCaseOperation2WithContext(ctx aws.Context, input *InputService16TestShapeInputService16TestCaseOperation2Input, opts ...request.Option) (*InputService16TestShapeInputService16TestCaseOperation2Output, error) { 2924 req, out := c.InputService16TestCaseOperation2Request(input) 2925 req.SetContext(ctx) 2926 req.ApplyOptions(opts...) 2927 return out, req.Send() 2928} 2929 2930type InputService16TestShapeInputService16TestCaseOperation1Input struct { 2931 _ struct{} `type:"structure"` 2932 2933 BoolQuery *bool `location:"querystring" locationName:"bool-query" type:"boolean"` 2934} 2935 2936// SetBoolQuery sets the BoolQuery field's value. 2937func (s *InputService16TestShapeInputService16TestCaseOperation1Input) SetBoolQuery(v bool) *InputService16TestShapeInputService16TestCaseOperation1Input { 2938 s.BoolQuery = &v 2939 return s 2940} 2941 2942type InputService16TestShapeInputService16TestCaseOperation1Output struct { 2943 _ struct{} `type:"structure"` 2944} 2945 2946type InputService16TestShapeInputService16TestCaseOperation2Input struct { 2947 _ struct{} `type:"structure"` 2948 2949 BoolQuery *bool `location:"querystring" locationName:"bool-query" type:"boolean"` 2950} 2951 2952// SetBoolQuery sets the BoolQuery field's value. 2953func (s *InputService16TestShapeInputService16TestCaseOperation2Input) SetBoolQuery(v bool) *InputService16TestShapeInputService16TestCaseOperation2Input { 2954 s.BoolQuery = &v 2955 return s 2956} 2957 2958type InputService16TestShapeInputService16TestCaseOperation2Output struct { 2959 _ struct{} `type:"structure"` 2960} 2961 2962// InputService17ProtocolTest provides the API operation methods for making requests to 2963// . See this package's package overview docs 2964// for details on the service. 2965// 2966// InputService17ProtocolTest methods are safe to use concurrently. It is not safe to 2967// modify mutate any of the struct's properties though. 2968type InputService17ProtocolTest struct { 2969 *client.Client 2970} 2971 2972// New creates a new instance of the InputService17ProtocolTest client with a session. 2973// If additional configuration is needed for the client instance use the optional 2974// aws.Config parameter to add your extra config. 2975// 2976// Example: 2977// // Create a InputService17ProtocolTest client from just a session. 2978// svc := inputservice17protocoltest.New(mySession) 2979// 2980// // Create a InputService17ProtocolTest client with additional configuration 2981// svc := inputservice17protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2982func NewInputService17ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService17ProtocolTest { 2983 c := p.ClientConfig("inputservice17protocoltest", cfgs...) 2984 return newInputService17ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2985} 2986 2987// newClient creates, initializes and returns a new service client instance. 2988func newInputService17ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService17ProtocolTest { 2989 svc := &InputService17ProtocolTest{ 2990 Client: client.New( 2991 cfg, 2992 metadata.ClientInfo{ 2993 ServiceName: "InputService17ProtocolTest", 2994 ServiceID: "InputService17ProtocolTest", 2995 SigningName: signingName, 2996 SigningRegion: signingRegion, 2997 Endpoint: endpoint, 2998 APIVersion: "2014-01-01", 2999 }, 3000 handlers, 3001 ), 3002 } 3003 3004 // Handlers 3005 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 3006 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 3007 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 3008 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 3009 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 3010 3011 return svc 3012} 3013 3014// newRequest creates a new request for a InputService17ProtocolTest operation and runs any 3015// custom request initialization. 3016func (c *InputService17ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 3017 req := c.NewRequest(op, params, data) 3018 3019 return req 3020} 3021 3022const opInputService17TestCaseOperation1 = "OperationName" 3023 3024// InputService17TestCaseOperation1Request generates a "aws/request.Request" representing the 3025// client's request for the InputService17TestCaseOperation1 operation. The "output" return 3026// value will be populated with the request's response once the request completes 3027// successfully. 3028// 3029// Use "Send" method on the returned Request to send the API call to the service. 3030// the "output" return value is not valid until after Send returns without error. 3031// 3032// See InputService17TestCaseOperation1 for more information on using the InputService17TestCaseOperation1 3033// API call, and error handling. 3034// 3035// This method is useful when you want to inject custom logic or configuration 3036// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3037// 3038// 3039// // Example sending a request using the InputService17TestCaseOperation1Request method. 3040// req, resp := client.InputService17TestCaseOperation1Request(params) 3041// 3042// err := req.Send() 3043// if err == nil { // resp is now filled 3044// fmt.Println(resp) 3045// } 3046func (c *InputService17ProtocolTest) InputService17TestCaseOperation1Request(input *InputService17TestShapeInputService17TestCaseOperation1Input) (req *request.Request, output *InputService17TestShapeInputService17TestCaseOperation1Output) { 3047 op := &request.Operation{ 3048 Name: opInputService17TestCaseOperation1, 3049 HTTPMethod: "POST", 3050 HTTPPath: "/", 3051 } 3052 3053 if input == nil { 3054 input = &InputService17TestShapeInputService17TestCaseOperation1Input{} 3055 } 3056 3057 output = &InputService17TestShapeInputService17TestCaseOperation1Output{} 3058 req = c.newRequest(op, input, output) 3059 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3060 return 3061} 3062 3063// InputService17TestCaseOperation1 API operation for . 3064// 3065// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3066// with awserr.Error's Code and Message methods to get detailed information about 3067// the error. 3068// 3069// See the AWS API reference guide for 's 3070// API operation InputService17TestCaseOperation1 for usage and error information. 3071func (c *InputService17ProtocolTest) InputService17TestCaseOperation1(input *InputService17TestShapeInputService17TestCaseOperation1Input) (*InputService17TestShapeInputService17TestCaseOperation1Output, error) { 3072 req, out := c.InputService17TestCaseOperation1Request(input) 3073 return out, req.Send() 3074} 3075 3076// InputService17TestCaseOperation1WithContext is the same as InputService17TestCaseOperation1 with the addition of 3077// the ability to pass a context and additional request options. 3078// 3079// See InputService17TestCaseOperation1 for details on how to use this API operation. 3080// 3081// The context must be non-nil and will be used for request cancellation. If 3082// the context is nil a panic will occur. In the future the SDK may create 3083// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3084// for more information on using Contexts. 3085func (c *InputService17ProtocolTest) InputService17TestCaseOperation1WithContext(ctx aws.Context, input *InputService17TestShapeInputService17TestCaseOperation1Input, opts ...request.Option) (*InputService17TestShapeInputService17TestCaseOperation1Output, error) { 3086 req, out := c.InputService17TestCaseOperation1Request(input) 3087 req.SetContext(ctx) 3088 req.ApplyOptions(opts...) 3089 return out, req.Send() 3090} 3091 3092type InputService17TestShapeInputService17TestCaseOperation1Input struct { 3093 _ struct{} `type:"structure" payload:"Foo"` 3094 3095 Foo *string `locationName:"foo" type:"string"` 3096} 3097 3098// SetFoo sets the Foo field's value. 3099func (s *InputService17TestShapeInputService17TestCaseOperation1Input) SetFoo(v string) *InputService17TestShapeInputService17TestCaseOperation1Input { 3100 s.Foo = &v 3101 return s 3102} 3103 3104type InputService17TestShapeInputService17TestCaseOperation1Output struct { 3105 _ struct{} `type:"structure"` 3106} 3107 3108// InputService18ProtocolTest provides the API operation methods for making requests to 3109// . See this package's package overview docs 3110// for details on the service. 3111// 3112// InputService18ProtocolTest methods are safe to use concurrently. It is not safe to 3113// modify mutate any of the struct's properties though. 3114type InputService18ProtocolTest struct { 3115 *client.Client 3116} 3117 3118// New creates a new instance of the InputService18ProtocolTest client with a session. 3119// If additional configuration is needed for the client instance use the optional 3120// aws.Config parameter to add your extra config. 3121// 3122// Example: 3123// // Create a InputService18ProtocolTest client from just a session. 3124// svc := inputservice18protocoltest.New(mySession) 3125// 3126// // Create a InputService18ProtocolTest client with additional configuration 3127// svc := inputservice18protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 3128func NewInputService18ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService18ProtocolTest { 3129 c := p.ClientConfig("inputservice18protocoltest", cfgs...) 3130 return newInputService18ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 3131} 3132 3133// newClient creates, initializes and returns a new service client instance. 3134func newInputService18ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService18ProtocolTest { 3135 svc := &InputService18ProtocolTest{ 3136 Client: client.New( 3137 cfg, 3138 metadata.ClientInfo{ 3139 ServiceName: "InputService18ProtocolTest", 3140 ServiceID: "InputService18ProtocolTest", 3141 SigningName: signingName, 3142 SigningRegion: signingRegion, 3143 Endpoint: endpoint, 3144 APIVersion: "2014-01-01", 3145 }, 3146 handlers, 3147 ), 3148 } 3149 3150 // Handlers 3151 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 3152 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 3153 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 3154 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 3155 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 3156 3157 return svc 3158} 3159 3160// newRequest creates a new request for a InputService18ProtocolTest operation and runs any 3161// custom request initialization. 3162func (c *InputService18ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 3163 req := c.NewRequest(op, params, data) 3164 3165 return req 3166} 3167 3168const opInputService18TestCaseOperation1 = "OperationName" 3169 3170// InputService18TestCaseOperation1Request generates a "aws/request.Request" representing the 3171// client's request for the InputService18TestCaseOperation1 operation. The "output" return 3172// value will be populated with the request's response once the request completes 3173// successfully. 3174// 3175// Use "Send" method on the returned Request to send the API call to the service. 3176// the "output" return value is not valid until after Send returns without error. 3177// 3178// See InputService18TestCaseOperation1 for more information on using the InputService18TestCaseOperation1 3179// API call, and error handling. 3180// 3181// This method is useful when you want to inject custom logic or configuration 3182// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3183// 3184// 3185// // Example sending a request using the InputService18TestCaseOperation1Request method. 3186// req, resp := client.InputService18TestCaseOperation1Request(params) 3187// 3188// err := req.Send() 3189// if err == nil { // resp is now filled 3190// fmt.Println(resp) 3191// } 3192func (c *InputService18ProtocolTest) InputService18TestCaseOperation1Request(input *InputService18TestShapeInputService18TestCaseOperation1Input) (req *request.Request, output *InputService18TestShapeInputService18TestCaseOperation1Output) { 3193 op := &request.Operation{ 3194 Name: opInputService18TestCaseOperation1, 3195 HTTPMethod: "POST", 3196 HTTPPath: "/", 3197 } 3198 3199 if input == nil { 3200 input = &InputService18TestShapeInputService18TestCaseOperation1Input{} 3201 } 3202 3203 output = &InputService18TestShapeInputService18TestCaseOperation1Output{} 3204 req = c.newRequest(op, input, output) 3205 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3206 return 3207} 3208 3209// InputService18TestCaseOperation1 API operation for . 3210// 3211// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3212// with awserr.Error's Code and Message methods to get detailed information about 3213// the error. 3214// 3215// See the AWS API reference guide for 's 3216// API operation InputService18TestCaseOperation1 for usage and error information. 3217func (c *InputService18ProtocolTest) InputService18TestCaseOperation1(input *InputService18TestShapeInputService18TestCaseOperation1Input) (*InputService18TestShapeInputService18TestCaseOperation1Output, error) { 3218 req, out := c.InputService18TestCaseOperation1Request(input) 3219 return out, req.Send() 3220} 3221 3222// InputService18TestCaseOperation1WithContext is the same as InputService18TestCaseOperation1 with the addition of 3223// the ability to pass a context and additional request options. 3224// 3225// See InputService18TestCaseOperation1 for details on how to use this API operation. 3226// 3227// The context must be non-nil and will be used for request cancellation. If 3228// the context is nil a panic will occur. In the future the SDK may create 3229// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3230// for more information on using Contexts. 3231func (c *InputService18ProtocolTest) InputService18TestCaseOperation1WithContext(ctx aws.Context, input *InputService18TestShapeInputService18TestCaseOperation1Input, opts ...request.Option) (*InputService18TestShapeInputService18TestCaseOperation1Output, error) { 3232 req, out := c.InputService18TestCaseOperation1Request(input) 3233 req.SetContext(ctx) 3234 req.ApplyOptions(opts...) 3235 return out, req.Send() 3236} 3237 3238const opInputService18TestCaseOperation2 = "OperationName" 3239 3240// InputService18TestCaseOperation2Request generates a "aws/request.Request" representing the 3241// client's request for the InputService18TestCaseOperation2 operation. The "output" return 3242// value will be populated with the request's response once the request completes 3243// successfully. 3244// 3245// Use "Send" method on the returned Request to send the API call to the service. 3246// the "output" return value is not valid until after Send returns without error. 3247// 3248// See InputService18TestCaseOperation2 for more information on using the InputService18TestCaseOperation2 3249// API call, and error handling. 3250// 3251// This method is useful when you want to inject custom logic or configuration 3252// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3253// 3254// 3255// // Example sending a request using the InputService18TestCaseOperation2Request method. 3256// req, resp := client.InputService18TestCaseOperation2Request(params) 3257// 3258// err := req.Send() 3259// if err == nil { // resp is now filled 3260// fmt.Println(resp) 3261// } 3262func (c *InputService18ProtocolTest) InputService18TestCaseOperation2Request(input *InputService18TestShapeInputService18TestCaseOperation2Input) (req *request.Request, output *InputService18TestShapeInputService18TestCaseOperation2Output) { 3263 op := &request.Operation{ 3264 Name: opInputService18TestCaseOperation2, 3265 HTTPMethod: "POST", 3266 HTTPPath: "/", 3267 } 3268 3269 if input == nil { 3270 input = &InputService18TestShapeInputService18TestCaseOperation2Input{} 3271 } 3272 3273 output = &InputService18TestShapeInputService18TestCaseOperation2Output{} 3274 req = c.newRequest(op, input, output) 3275 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3276 return 3277} 3278 3279// InputService18TestCaseOperation2 API operation for . 3280// 3281// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3282// with awserr.Error's Code and Message methods to get detailed information about 3283// the error. 3284// 3285// See the AWS API reference guide for 's 3286// API operation InputService18TestCaseOperation2 for usage and error information. 3287func (c *InputService18ProtocolTest) InputService18TestCaseOperation2(input *InputService18TestShapeInputService18TestCaseOperation2Input) (*InputService18TestShapeInputService18TestCaseOperation2Output, error) { 3288 req, out := c.InputService18TestCaseOperation2Request(input) 3289 return out, req.Send() 3290} 3291 3292// InputService18TestCaseOperation2WithContext is the same as InputService18TestCaseOperation2 with the addition of 3293// the ability to pass a context and additional request options. 3294// 3295// See InputService18TestCaseOperation2 for details on how to use this API operation. 3296// 3297// The context must be non-nil and will be used for request cancellation. If 3298// the context is nil a panic will occur. In the future the SDK may create 3299// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3300// for more information on using Contexts. 3301func (c *InputService18ProtocolTest) InputService18TestCaseOperation2WithContext(ctx aws.Context, input *InputService18TestShapeInputService18TestCaseOperation2Input, opts ...request.Option) (*InputService18TestShapeInputService18TestCaseOperation2Output, error) { 3302 req, out := c.InputService18TestCaseOperation2Request(input) 3303 req.SetContext(ctx) 3304 req.ApplyOptions(opts...) 3305 return out, req.Send() 3306} 3307 3308type InputService18TestShapeInputService18TestCaseOperation1Input struct { 3309 _ struct{} `type:"structure" payload:"Foo"` 3310 3311 Foo []byte `locationName:"foo" type:"blob"` 3312} 3313 3314// SetFoo sets the Foo field's value. 3315func (s *InputService18TestShapeInputService18TestCaseOperation1Input) SetFoo(v []byte) *InputService18TestShapeInputService18TestCaseOperation1Input { 3316 s.Foo = v 3317 return s 3318} 3319 3320type InputService18TestShapeInputService18TestCaseOperation1Output struct { 3321 _ struct{} `type:"structure"` 3322} 3323 3324type InputService18TestShapeInputService18TestCaseOperation2Input struct { 3325 _ struct{} `type:"structure" payload:"Foo"` 3326 3327 Foo []byte `locationName:"foo" type:"blob"` 3328} 3329 3330// SetFoo sets the Foo field's value. 3331func (s *InputService18TestShapeInputService18TestCaseOperation2Input) SetFoo(v []byte) *InputService18TestShapeInputService18TestCaseOperation2Input { 3332 s.Foo = v 3333 return s 3334} 3335 3336type InputService18TestShapeInputService18TestCaseOperation2Output struct { 3337 _ struct{} `type:"structure"` 3338} 3339 3340// InputService19ProtocolTest provides the API operation methods for making requests to 3341// . See this package's package overview docs 3342// for details on the service. 3343// 3344// InputService19ProtocolTest methods are safe to use concurrently. It is not safe to 3345// modify mutate any of the struct's properties though. 3346type InputService19ProtocolTest struct { 3347 *client.Client 3348} 3349 3350// New creates a new instance of the InputService19ProtocolTest client with a session. 3351// If additional configuration is needed for the client instance use the optional 3352// aws.Config parameter to add your extra config. 3353// 3354// Example: 3355// // Create a InputService19ProtocolTest client from just a session. 3356// svc := inputservice19protocoltest.New(mySession) 3357// 3358// // Create a InputService19ProtocolTest client with additional configuration 3359// svc := inputservice19protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 3360func NewInputService19ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService19ProtocolTest { 3361 c := p.ClientConfig("inputservice19protocoltest", cfgs...) 3362 return newInputService19ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 3363} 3364 3365// newClient creates, initializes and returns a new service client instance. 3366func newInputService19ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService19ProtocolTest { 3367 svc := &InputService19ProtocolTest{ 3368 Client: client.New( 3369 cfg, 3370 metadata.ClientInfo{ 3371 ServiceName: "InputService19ProtocolTest", 3372 ServiceID: "InputService19ProtocolTest", 3373 SigningName: signingName, 3374 SigningRegion: signingRegion, 3375 Endpoint: endpoint, 3376 APIVersion: "2014-01-01", 3377 }, 3378 handlers, 3379 ), 3380 } 3381 3382 // Handlers 3383 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 3384 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 3385 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 3386 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 3387 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 3388 3389 return svc 3390} 3391 3392// newRequest creates a new request for a InputService19ProtocolTest operation and runs any 3393// custom request initialization. 3394func (c *InputService19ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 3395 req := c.NewRequest(op, params, data) 3396 3397 return req 3398} 3399 3400const opInputService19TestCaseOperation1 = "OperationName" 3401 3402// InputService19TestCaseOperation1Request generates a "aws/request.Request" representing the 3403// client's request for the InputService19TestCaseOperation1 operation. The "output" return 3404// value will be populated with the request's response once the request completes 3405// successfully. 3406// 3407// Use "Send" method on the returned Request to send the API call to the service. 3408// the "output" return value is not valid until after Send returns without error. 3409// 3410// See InputService19TestCaseOperation1 for more information on using the InputService19TestCaseOperation1 3411// API call, and error handling. 3412// 3413// This method is useful when you want to inject custom logic or configuration 3414// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3415// 3416// 3417// // Example sending a request using the InputService19TestCaseOperation1Request method. 3418// req, resp := client.InputService19TestCaseOperation1Request(params) 3419// 3420// err := req.Send() 3421// if err == nil { // resp is now filled 3422// fmt.Println(resp) 3423// } 3424func (c *InputService19ProtocolTest) InputService19TestCaseOperation1Request(input *InputService19TestShapeInputService19TestCaseOperation1Input) (req *request.Request, output *InputService19TestShapeInputService19TestCaseOperation1Output) { 3425 op := &request.Operation{ 3426 Name: opInputService19TestCaseOperation1, 3427 HTTPMethod: "POST", 3428 HTTPPath: "/", 3429 } 3430 3431 if input == nil { 3432 input = &InputService19TestShapeInputService19TestCaseOperation1Input{} 3433 } 3434 3435 output = &InputService19TestShapeInputService19TestCaseOperation1Output{} 3436 req = c.newRequest(op, input, output) 3437 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3438 return 3439} 3440 3441// InputService19TestCaseOperation1 API operation for . 3442// 3443// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3444// with awserr.Error's Code and Message methods to get detailed information about 3445// the error. 3446// 3447// See the AWS API reference guide for 's 3448// API operation InputService19TestCaseOperation1 for usage and error information. 3449func (c *InputService19ProtocolTest) InputService19TestCaseOperation1(input *InputService19TestShapeInputService19TestCaseOperation1Input) (*InputService19TestShapeInputService19TestCaseOperation1Output, error) { 3450 req, out := c.InputService19TestCaseOperation1Request(input) 3451 return out, req.Send() 3452} 3453 3454// InputService19TestCaseOperation1WithContext is the same as InputService19TestCaseOperation1 with the addition of 3455// the ability to pass a context and additional request options. 3456// 3457// See InputService19TestCaseOperation1 for details on how to use this API operation. 3458// 3459// The context must be non-nil and will be used for request cancellation. If 3460// the context is nil a panic will occur. In the future the SDK may create 3461// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3462// for more information on using Contexts. 3463func (c *InputService19ProtocolTest) InputService19TestCaseOperation1WithContext(ctx aws.Context, input *InputService19TestShapeInputService19TestCaseOperation1Input, opts ...request.Option) (*InputService19TestShapeInputService19TestCaseOperation1Output, error) { 3464 req, out := c.InputService19TestCaseOperation1Request(input) 3465 req.SetContext(ctx) 3466 req.ApplyOptions(opts...) 3467 return out, req.Send() 3468} 3469 3470const opInputService19TestCaseOperation2 = "OperationName" 3471 3472// InputService19TestCaseOperation2Request generates a "aws/request.Request" representing the 3473// client's request for the InputService19TestCaseOperation2 operation. The "output" return 3474// value will be populated with the request's response once the request completes 3475// successfully. 3476// 3477// Use "Send" method on the returned Request to send the API call to the service. 3478// the "output" return value is not valid until after Send returns without error. 3479// 3480// See InputService19TestCaseOperation2 for more information on using the InputService19TestCaseOperation2 3481// API call, and error handling. 3482// 3483// This method is useful when you want to inject custom logic or configuration 3484// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3485// 3486// 3487// // Example sending a request using the InputService19TestCaseOperation2Request method. 3488// req, resp := client.InputService19TestCaseOperation2Request(params) 3489// 3490// err := req.Send() 3491// if err == nil { // resp is now filled 3492// fmt.Println(resp) 3493// } 3494func (c *InputService19ProtocolTest) InputService19TestCaseOperation2Request(input *InputService19TestShapeInputService19TestCaseOperation2Input) (req *request.Request, output *InputService19TestShapeInputService19TestCaseOperation2Output) { 3495 op := &request.Operation{ 3496 Name: opInputService19TestCaseOperation2, 3497 HTTPMethod: "POST", 3498 HTTPPath: "/", 3499 } 3500 3501 if input == nil { 3502 input = &InputService19TestShapeInputService19TestCaseOperation2Input{} 3503 } 3504 3505 output = &InputService19TestShapeInputService19TestCaseOperation2Output{} 3506 req = c.newRequest(op, input, output) 3507 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3508 return 3509} 3510 3511// InputService19TestCaseOperation2 API operation for . 3512// 3513// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3514// with awserr.Error's Code and Message methods to get detailed information about 3515// the error. 3516// 3517// See the AWS API reference guide for 's 3518// API operation InputService19TestCaseOperation2 for usage and error information. 3519func (c *InputService19ProtocolTest) InputService19TestCaseOperation2(input *InputService19TestShapeInputService19TestCaseOperation2Input) (*InputService19TestShapeInputService19TestCaseOperation2Output, error) { 3520 req, out := c.InputService19TestCaseOperation2Request(input) 3521 return out, req.Send() 3522} 3523 3524// InputService19TestCaseOperation2WithContext is the same as InputService19TestCaseOperation2 with the addition of 3525// the ability to pass a context and additional request options. 3526// 3527// See InputService19TestCaseOperation2 for details on how to use this API operation. 3528// 3529// The context must be non-nil and will be used for request cancellation. If 3530// the context is nil a panic will occur. In the future the SDK may create 3531// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3532// for more information on using Contexts. 3533func (c *InputService19ProtocolTest) InputService19TestCaseOperation2WithContext(ctx aws.Context, input *InputService19TestShapeInputService19TestCaseOperation2Input, opts ...request.Option) (*InputService19TestShapeInputService19TestCaseOperation2Output, error) { 3534 req, out := c.InputService19TestCaseOperation2Request(input) 3535 req.SetContext(ctx) 3536 req.ApplyOptions(opts...) 3537 return out, req.Send() 3538} 3539 3540const opInputService19TestCaseOperation3 = "OperationName" 3541 3542// InputService19TestCaseOperation3Request generates a "aws/request.Request" representing the 3543// client's request for the InputService19TestCaseOperation3 operation. The "output" return 3544// value will be populated with the request's response once the request completes 3545// successfully. 3546// 3547// Use "Send" method on the returned Request to send the API call to the service. 3548// the "output" return value is not valid until after Send returns without error. 3549// 3550// See InputService19TestCaseOperation3 for more information on using the InputService19TestCaseOperation3 3551// API call, and error handling. 3552// 3553// This method is useful when you want to inject custom logic or configuration 3554// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3555// 3556// 3557// // Example sending a request using the InputService19TestCaseOperation3Request method. 3558// req, resp := client.InputService19TestCaseOperation3Request(params) 3559// 3560// err := req.Send() 3561// if err == nil { // resp is now filled 3562// fmt.Println(resp) 3563// } 3564func (c *InputService19ProtocolTest) InputService19TestCaseOperation3Request(input *InputService19TestShapeInputService19TestCaseOperation3Input) (req *request.Request, output *InputService19TestShapeInputService19TestCaseOperation3Output) { 3565 op := &request.Operation{ 3566 Name: opInputService19TestCaseOperation3, 3567 HTTPMethod: "POST", 3568 HTTPPath: "/", 3569 } 3570 3571 if input == nil { 3572 input = &InputService19TestShapeInputService19TestCaseOperation3Input{} 3573 } 3574 3575 output = &InputService19TestShapeInputService19TestCaseOperation3Output{} 3576 req = c.newRequest(op, input, output) 3577 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3578 return 3579} 3580 3581// InputService19TestCaseOperation3 API operation for . 3582// 3583// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3584// with awserr.Error's Code and Message methods to get detailed information about 3585// the error. 3586// 3587// See the AWS API reference guide for 's 3588// API operation InputService19TestCaseOperation3 for usage and error information. 3589func (c *InputService19ProtocolTest) InputService19TestCaseOperation3(input *InputService19TestShapeInputService19TestCaseOperation3Input) (*InputService19TestShapeInputService19TestCaseOperation3Output, error) { 3590 req, out := c.InputService19TestCaseOperation3Request(input) 3591 return out, req.Send() 3592} 3593 3594// InputService19TestCaseOperation3WithContext is the same as InputService19TestCaseOperation3 with the addition of 3595// the ability to pass a context and additional request options. 3596// 3597// See InputService19TestCaseOperation3 for details on how to use this API operation. 3598// 3599// The context must be non-nil and will be used for request cancellation. If 3600// the context is nil a panic will occur. In the future the SDK may create 3601// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3602// for more information on using Contexts. 3603func (c *InputService19ProtocolTest) InputService19TestCaseOperation3WithContext(ctx aws.Context, input *InputService19TestShapeInputService19TestCaseOperation3Input, opts ...request.Option) (*InputService19TestShapeInputService19TestCaseOperation3Output, error) { 3604 req, out := c.InputService19TestCaseOperation3Request(input) 3605 req.SetContext(ctx) 3606 req.ApplyOptions(opts...) 3607 return out, req.Send() 3608} 3609 3610const opInputService19TestCaseOperation4 = "OperationName" 3611 3612// InputService19TestCaseOperation4Request generates a "aws/request.Request" representing the 3613// client's request for the InputService19TestCaseOperation4 operation. The "output" return 3614// value will be populated with the request's response once the request completes 3615// successfully. 3616// 3617// Use "Send" method on the returned Request to send the API call to the service. 3618// the "output" return value is not valid until after Send returns without error. 3619// 3620// See InputService19TestCaseOperation4 for more information on using the InputService19TestCaseOperation4 3621// API call, and error handling. 3622// 3623// This method is useful when you want to inject custom logic or configuration 3624// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3625// 3626// 3627// // Example sending a request using the InputService19TestCaseOperation4Request method. 3628// req, resp := client.InputService19TestCaseOperation4Request(params) 3629// 3630// err := req.Send() 3631// if err == nil { // resp is now filled 3632// fmt.Println(resp) 3633// } 3634func (c *InputService19ProtocolTest) InputService19TestCaseOperation4Request(input *InputService19TestShapeInputService19TestCaseOperation4Input) (req *request.Request, output *InputService19TestShapeInputService19TestCaseOperation4Output) { 3635 op := &request.Operation{ 3636 Name: opInputService19TestCaseOperation4, 3637 HTTPMethod: "POST", 3638 HTTPPath: "/", 3639 } 3640 3641 if input == nil { 3642 input = &InputService19TestShapeInputService19TestCaseOperation4Input{} 3643 } 3644 3645 output = &InputService19TestShapeInputService19TestCaseOperation4Output{} 3646 req = c.newRequest(op, input, output) 3647 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3648 return 3649} 3650 3651// InputService19TestCaseOperation4 API operation for . 3652// 3653// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3654// with awserr.Error's Code and Message methods to get detailed information about 3655// the error. 3656// 3657// See the AWS API reference guide for 's 3658// API operation InputService19TestCaseOperation4 for usage and error information. 3659func (c *InputService19ProtocolTest) InputService19TestCaseOperation4(input *InputService19TestShapeInputService19TestCaseOperation4Input) (*InputService19TestShapeInputService19TestCaseOperation4Output, error) { 3660 req, out := c.InputService19TestCaseOperation4Request(input) 3661 return out, req.Send() 3662} 3663 3664// InputService19TestCaseOperation4WithContext is the same as InputService19TestCaseOperation4 with the addition of 3665// the ability to pass a context and additional request options. 3666// 3667// See InputService19TestCaseOperation4 for details on how to use this API operation. 3668// 3669// The context must be non-nil and will be used for request cancellation. If 3670// the context is nil a panic will occur. In the future the SDK may create 3671// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3672// for more information on using Contexts. 3673func (c *InputService19ProtocolTest) InputService19TestCaseOperation4WithContext(ctx aws.Context, input *InputService19TestShapeInputService19TestCaseOperation4Input, opts ...request.Option) (*InputService19TestShapeInputService19TestCaseOperation4Output, error) { 3674 req, out := c.InputService19TestCaseOperation4Request(input) 3675 req.SetContext(ctx) 3676 req.ApplyOptions(opts...) 3677 return out, req.Send() 3678} 3679 3680type InputService19TestShapeFooShape struct { 3681 _ struct{} `locationName:"foo" type:"structure"` 3682 3683 Baz *string `locationName:"baz" type:"string"` 3684} 3685 3686// SetBaz sets the Baz field's value. 3687func (s *InputService19TestShapeFooShape) SetBaz(v string) *InputService19TestShapeFooShape { 3688 s.Baz = &v 3689 return s 3690} 3691 3692type InputService19TestShapeInputService19TestCaseOperation1Input struct { 3693 _ struct{} `type:"structure" payload:"Foo"` 3694 3695 Foo *InputService19TestShapeFooShape `locationName:"foo" type:"structure"` 3696} 3697 3698// SetFoo sets the Foo field's value. 3699func (s *InputService19TestShapeInputService19TestCaseOperation1Input) SetFoo(v *InputService19TestShapeFooShape) *InputService19TestShapeInputService19TestCaseOperation1Input { 3700 s.Foo = v 3701 return s 3702} 3703 3704type InputService19TestShapeInputService19TestCaseOperation1Output struct { 3705 _ struct{} `type:"structure"` 3706} 3707 3708type InputService19TestShapeInputService19TestCaseOperation2Input struct { 3709 _ struct{} `type:"structure" payload:"Foo"` 3710 3711 Foo *InputService19TestShapeFooShape `locationName:"foo" type:"structure"` 3712} 3713 3714// SetFoo sets the Foo field's value. 3715func (s *InputService19TestShapeInputService19TestCaseOperation2Input) SetFoo(v *InputService19TestShapeFooShape) *InputService19TestShapeInputService19TestCaseOperation2Input { 3716 s.Foo = v 3717 return s 3718} 3719 3720type InputService19TestShapeInputService19TestCaseOperation2Output struct { 3721 _ struct{} `type:"structure"` 3722} 3723 3724type InputService19TestShapeInputService19TestCaseOperation3Input struct { 3725 _ struct{} `type:"structure" payload:"Foo"` 3726 3727 Foo *InputService19TestShapeFooShape `locationName:"foo" type:"structure"` 3728} 3729 3730// SetFoo sets the Foo field's value. 3731func (s *InputService19TestShapeInputService19TestCaseOperation3Input) SetFoo(v *InputService19TestShapeFooShape) *InputService19TestShapeInputService19TestCaseOperation3Input { 3732 s.Foo = v 3733 return s 3734} 3735 3736type InputService19TestShapeInputService19TestCaseOperation3Output struct { 3737 _ struct{} `type:"structure"` 3738} 3739 3740type InputService19TestShapeInputService19TestCaseOperation4Input struct { 3741 _ struct{} `type:"structure" payload:"Foo"` 3742 3743 Foo *InputService19TestShapeFooShape `locationName:"foo" type:"structure"` 3744} 3745 3746// SetFoo sets the Foo field's value. 3747func (s *InputService19TestShapeInputService19TestCaseOperation4Input) SetFoo(v *InputService19TestShapeFooShape) *InputService19TestShapeInputService19TestCaseOperation4Input { 3748 s.Foo = v 3749 return s 3750} 3751 3752type InputService19TestShapeInputService19TestCaseOperation4Output struct { 3753 _ struct{} `type:"structure"` 3754} 3755 3756// InputService20ProtocolTest provides the API operation methods for making requests to 3757// . See this package's package overview docs 3758// for details on the service. 3759// 3760// InputService20ProtocolTest methods are safe to use concurrently. It is not safe to 3761// modify mutate any of the struct's properties though. 3762type InputService20ProtocolTest struct { 3763 *client.Client 3764} 3765 3766// New creates a new instance of the InputService20ProtocolTest client with a session. 3767// If additional configuration is needed for the client instance use the optional 3768// aws.Config parameter to add your extra config. 3769// 3770// Example: 3771// // Create a InputService20ProtocolTest client from just a session. 3772// svc := inputservice20protocoltest.New(mySession) 3773// 3774// // Create a InputService20ProtocolTest client with additional configuration 3775// svc := inputservice20protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 3776func NewInputService20ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService20ProtocolTest { 3777 c := p.ClientConfig("inputservice20protocoltest", cfgs...) 3778 return newInputService20ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 3779} 3780 3781// newClient creates, initializes and returns a new service client instance. 3782func newInputService20ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService20ProtocolTest { 3783 svc := &InputService20ProtocolTest{ 3784 Client: client.New( 3785 cfg, 3786 metadata.ClientInfo{ 3787 ServiceName: "InputService20ProtocolTest", 3788 ServiceID: "InputService20ProtocolTest", 3789 SigningName: signingName, 3790 SigningRegion: signingRegion, 3791 Endpoint: endpoint, 3792 APIVersion: "2014-01-01", 3793 }, 3794 handlers, 3795 ), 3796 } 3797 3798 // Handlers 3799 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 3800 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 3801 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 3802 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 3803 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 3804 3805 return svc 3806} 3807 3808// newRequest creates a new request for a InputService20ProtocolTest operation and runs any 3809// custom request initialization. 3810func (c *InputService20ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 3811 req := c.NewRequest(op, params, data) 3812 3813 return req 3814} 3815 3816const opInputService20TestCaseOperation1 = "OperationName" 3817 3818// InputService20TestCaseOperation1Request generates a "aws/request.Request" representing the 3819// client's request for the InputService20TestCaseOperation1 operation. The "output" return 3820// value will be populated with the request's response once the request completes 3821// successfully. 3822// 3823// Use "Send" method on the returned Request to send the API call to the service. 3824// the "output" return value is not valid until after Send returns without error. 3825// 3826// See InputService20TestCaseOperation1 for more information on using the InputService20TestCaseOperation1 3827// API call, and error handling. 3828// 3829// This method is useful when you want to inject custom logic or configuration 3830// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3831// 3832// 3833// // Example sending a request using the InputService20TestCaseOperation1Request method. 3834// req, resp := client.InputService20TestCaseOperation1Request(params) 3835// 3836// err := req.Send() 3837// if err == nil { // resp is now filled 3838// fmt.Println(resp) 3839// } 3840func (c *InputService20ProtocolTest) InputService20TestCaseOperation1Request(input *InputService20TestShapeInputService20TestCaseOperation1Input) (req *request.Request, output *InputService20TestShapeInputService20TestCaseOperation1Output) { 3841 op := &request.Operation{ 3842 Name: opInputService20TestCaseOperation1, 3843 HTTPMethod: "POST", 3844 HTTPPath: "/", 3845 } 3846 3847 if input == nil { 3848 input = &InputService20TestShapeInputService20TestCaseOperation1Input{} 3849 } 3850 3851 output = &InputService20TestShapeInputService20TestCaseOperation1Output{} 3852 req = c.newRequest(op, input, output) 3853 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 3854 return 3855} 3856 3857// InputService20TestCaseOperation1 API operation for . 3858// 3859// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3860// with awserr.Error's Code and Message methods to get detailed information about 3861// the error. 3862// 3863// See the AWS API reference guide for 's 3864// API operation InputService20TestCaseOperation1 for usage and error information. 3865func (c *InputService20ProtocolTest) InputService20TestCaseOperation1(input *InputService20TestShapeInputService20TestCaseOperation1Input) (*InputService20TestShapeInputService20TestCaseOperation1Output, error) { 3866 req, out := c.InputService20TestCaseOperation1Request(input) 3867 return out, req.Send() 3868} 3869 3870// InputService20TestCaseOperation1WithContext is the same as InputService20TestCaseOperation1 with the addition of 3871// the ability to pass a context and additional request options. 3872// 3873// See InputService20TestCaseOperation1 for details on how to use this API operation. 3874// 3875// The context must be non-nil and will be used for request cancellation. If 3876// the context is nil a panic will occur. In the future the SDK may create 3877// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3878// for more information on using Contexts. 3879func (c *InputService20ProtocolTest) InputService20TestCaseOperation1WithContext(ctx aws.Context, input *InputService20TestShapeInputService20TestCaseOperation1Input, opts ...request.Option) (*InputService20TestShapeInputService20TestCaseOperation1Output, error) { 3880 req, out := c.InputService20TestCaseOperation1Request(input) 3881 req.SetContext(ctx) 3882 req.ApplyOptions(opts...) 3883 return out, req.Send() 3884} 3885 3886type InputService20TestShapeGrant struct { 3887 _ struct{} `locationName:"Grant" type:"structure"` 3888 3889 Grantee *InputService20TestShapeGrantee `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"` 3890} 3891 3892// SetGrantee sets the Grantee field's value. 3893func (s *InputService20TestShapeGrant) SetGrantee(v *InputService20TestShapeGrantee) *InputService20TestShapeGrant { 3894 s.Grantee = v 3895 return s 3896} 3897 3898type InputService20TestShapeGrantee struct { 3899 _ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"` 3900 3901 EmailAddress *string `type:"string"` 3902 3903 Type *string `locationName:"xsi:type" type:"string" xmlAttribute:"true"` 3904} 3905 3906// SetEmailAddress sets the EmailAddress field's value. 3907func (s *InputService20TestShapeGrantee) SetEmailAddress(v string) *InputService20TestShapeGrantee { 3908 s.EmailAddress = &v 3909 return s 3910} 3911 3912// SetType sets the Type field's value. 3913func (s *InputService20TestShapeGrantee) SetType(v string) *InputService20TestShapeGrantee { 3914 s.Type = &v 3915 return s 3916} 3917 3918type InputService20TestShapeInputService20TestCaseOperation1Input struct { 3919 _ struct{} `type:"structure" payload:"Grant"` 3920 3921 Grant *InputService20TestShapeGrant `locationName:"Grant" type:"structure"` 3922} 3923 3924// SetGrant sets the Grant field's value. 3925func (s *InputService20TestShapeInputService20TestCaseOperation1Input) SetGrant(v *InputService20TestShapeGrant) *InputService20TestShapeInputService20TestCaseOperation1Input { 3926 s.Grant = v 3927 return s 3928} 3929 3930type InputService20TestShapeInputService20TestCaseOperation1Output struct { 3931 _ struct{} `type:"structure"` 3932} 3933 3934// InputService21ProtocolTest provides the API operation methods for making requests to 3935// . See this package's package overview docs 3936// for details on the service. 3937// 3938// InputService21ProtocolTest methods are safe to use concurrently. It is not safe to 3939// modify mutate any of the struct's properties though. 3940type InputService21ProtocolTest struct { 3941 *client.Client 3942} 3943 3944// New creates a new instance of the InputService21ProtocolTest client with a session. 3945// If additional configuration is needed for the client instance use the optional 3946// aws.Config parameter to add your extra config. 3947// 3948// Example: 3949// // Create a InputService21ProtocolTest client from just a session. 3950// svc := inputservice21protocoltest.New(mySession) 3951// 3952// // Create a InputService21ProtocolTest client with additional configuration 3953// svc := inputservice21protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 3954func NewInputService21ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService21ProtocolTest { 3955 c := p.ClientConfig("inputservice21protocoltest", cfgs...) 3956 return newInputService21ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 3957} 3958 3959// newClient creates, initializes and returns a new service client instance. 3960func newInputService21ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService21ProtocolTest { 3961 svc := &InputService21ProtocolTest{ 3962 Client: client.New( 3963 cfg, 3964 metadata.ClientInfo{ 3965 ServiceName: "InputService21ProtocolTest", 3966 ServiceID: "InputService21ProtocolTest", 3967 SigningName: signingName, 3968 SigningRegion: signingRegion, 3969 Endpoint: endpoint, 3970 APIVersion: "2014-01-01", 3971 }, 3972 handlers, 3973 ), 3974 } 3975 3976 // Handlers 3977 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 3978 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 3979 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 3980 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 3981 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 3982 3983 return svc 3984} 3985 3986// newRequest creates a new request for a InputService21ProtocolTest operation and runs any 3987// custom request initialization. 3988func (c *InputService21ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 3989 req := c.NewRequest(op, params, data) 3990 3991 return req 3992} 3993 3994const opInputService21TestCaseOperation1 = "OperationName" 3995 3996// InputService21TestCaseOperation1Request generates a "aws/request.Request" representing the 3997// client's request for the InputService21TestCaseOperation1 operation. The "output" return 3998// value will be populated with the request's response once the request completes 3999// successfully. 4000// 4001// Use "Send" method on the returned Request to send the API call to the service. 4002// the "output" return value is not valid until after Send returns without error. 4003// 4004// See InputService21TestCaseOperation1 for more information on using the InputService21TestCaseOperation1 4005// API call, and error handling. 4006// 4007// This method is useful when you want to inject custom logic or configuration 4008// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4009// 4010// 4011// // Example sending a request using the InputService21TestCaseOperation1Request method. 4012// req, resp := client.InputService21TestCaseOperation1Request(params) 4013// 4014// err := req.Send() 4015// if err == nil { // resp is now filled 4016// fmt.Println(resp) 4017// } 4018func (c *InputService21ProtocolTest) InputService21TestCaseOperation1Request(input *InputService21TestShapeInputService21TestCaseOperation1Input) (req *request.Request, output *InputService21TestShapeInputService21TestCaseOperation1Output) { 4019 op := &request.Operation{ 4020 Name: opInputService21TestCaseOperation1, 4021 HTTPMethod: "GET", 4022 HTTPPath: "/{Bucket}/{Key+}", 4023 } 4024 4025 if input == nil { 4026 input = &InputService21TestShapeInputService21TestCaseOperation1Input{} 4027 } 4028 4029 output = &InputService21TestShapeInputService21TestCaseOperation1Output{} 4030 req = c.newRequest(op, input, output) 4031 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4032 return 4033} 4034 4035// InputService21TestCaseOperation1 API operation for . 4036// 4037// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4038// with awserr.Error's Code and Message methods to get detailed information about 4039// the error. 4040// 4041// See the AWS API reference guide for 's 4042// API operation InputService21TestCaseOperation1 for usage and error information. 4043func (c *InputService21ProtocolTest) InputService21TestCaseOperation1(input *InputService21TestShapeInputService21TestCaseOperation1Input) (*InputService21TestShapeInputService21TestCaseOperation1Output, error) { 4044 req, out := c.InputService21TestCaseOperation1Request(input) 4045 return out, req.Send() 4046} 4047 4048// InputService21TestCaseOperation1WithContext is the same as InputService21TestCaseOperation1 with the addition of 4049// the ability to pass a context and additional request options. 4050// 4051// See InputService21TestCaseOperation1 for details on how to use this API operation. 4052// 4053// The context must be non-nil and will be used for request cancellation. If 4054// the context is nil a panic will occur. In the future the SDK may create 4055// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4056// for more information on using Contexts. 4057func (c *InputService21ProtocolTest) InputService21TestCaseOperation1WithContext(ctx aws.Context, input *InputService21TestShapeInputService21TestCaseOperation1Input, opts ...request.Option) (*InputService21TestShapeInputService21TestCaseOperation1Output, error) { 4058 req, out := c.InputService21TestCaseOperation1Request(input) 4059 req.SetContext(ctx) 4060 req.ApplyOptions(opts...) 4061 return out, req.Send() 4062} 4063 4064type InputService21TestShapeInputService21TestCaseOperation1Input struct { 4065 _ struct{} `type:"structure"` 4066 4067 // Bucket is a required field 4068 Bucket *string `location:"uri" type:"string" required:"true"` 4069 4070 // Key is a required field 4071 Key *string `location:"uri" type:"string" required:"true"` 4072} 4073 4074// Validate inspects the fields of the type to determine if they are valid. 4075func (s *InputService21TestShapeInputService21TestCaseOperation1Input) Validate() error { 4076 invalidParams := request.ErrInvalidParams{Context: "InputService21TestShapeInputService21TestCaseOperation1Input"} 4077 if s.Bucket == nil { 4078 invalidParams.Add(request.NewErrParamRequired("Bucket")) 4079 } 4080 if s.Bucket != nil && len(*s.Bucket) < 1 { 4081 invalidParams.Add(request.NewErrParamMinLen("Bucket", 1)) 4082 } 4083 if s.Key == nil { 4084 invalidParams.Add(request.NewErrParamRequired("Key")) 4085 } 4086 if s.Key != nil && len(*s.Key) < 1 { 4087 invalidParams.Add(request.NewErrParamMinLen("Key", 1)) 4088 } 4089 4090 if invalidParams.Len() > 0 { 4091 return invalidParams 4092 } 4093 return nil 4094} 4095 4096// SetBucket sets the Bucket field's value. 4097func (s *InputService21TestShapeInputService21TestCaseOperation1Input) SetBucket(v string) *InputService21TestShapeInputService21TestCaseOperation1Input { 4098 s.Bucket = &v 4099 return s 4100} 4101 4102// SetKey sets the Key field's value. 4103func (s *InputService21TestShapeInputService21TestCaseOperation1Input) SetKey(v string) *InputService21TestShapeInputService21TestCaseOperation1Input { 4104 s.Key = &v 4105 return s 4106} 4107 4108type InputService21TestShapeInputService21TestCaseOperation1Output struct { 4109 _ struct{} `type:"structure"` 4110} 4111 4112// InputService22ProtocolTest provides the API operation methods for making requests to 4113// . See this package's package overview docs 4114// for details on the service. 4115// 4116// InputService22ProtocolTest methods are safe to use concurrently. It is not safe to 4117// modify mutate any of the struct's properties though. 4118type InputService22ProtocolTest struct { 4119 *client.Client 4120} 4121 4122// New creates a new instance of the InputService22ProtocolTest client with a session. 4123// If additional configuration is needed for the client instance use the optional 4124// aws.Config parameter to add your extra config. 4125// 4126// Example: 4127// // Create a InputService22ProtocolTest client from just a session. 4128// svc := inputservice22protocoltest.New(mySession) 4129// 4130// // Create a InputService22ProtocolTest client with additional configuration 4131// svc := inputservice22protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 4132func NewInputService22ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService22ProtocolTest { 4133 c := p.ClientConfig("inputservice22protocoltest", cfgs...) 4134 return newInputService22ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 4135} 4136 4137// newClient creates, initializes and returns a new service client instance. 4138func newInputService22ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService22ProtocolTest { 4139 svc := &InputService22ProtocolTest{ 4140 Client: client.New( 4141 cfg, 4142 metadata.ClientInfo{ 4143 ServiceName: "InputService22ProtocolTest", 4144 ServiceID: "InputService22ProtocolTest", 4145 SigningName: signingName, 4146 SigningRegion: signingRegion, 4147 Endpoint: endpoint, 4148 APIVersion: "2014-01-01", 4149 }, 4150 handlers, 4151 ), 4152 } 4153 4154 // Handlers 4155 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 4156 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 4157 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 4158 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 4159 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 4160 4161 return svc 4162} 4163 4164// newRequest creates a new request for a InputService22ProtocolTest operation and runs any 4165// custom request initialization. 4166func (c *InputService22ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 4167 req := c.NewRequest(op, params, data) 4168 4169 return req 4170} 4171 4172const opInputService22TestCaseOperation1 = "OperationName" 4173 4174// InputService22TestCaseOperation1Request generates a "aws/request.Request" representing the 4175// client's request for the InputService22TestCaseOperation1 operation. The "output" return 4176// value will be populated with the request's response once the request completes 4177// successfully. 4178// 4179// Use "Send" method on the returned Request to send the API call to the service. 4180// the "output" return value is not valid until after Send returns without error. 4181// 4182// See InputService22TestCaseOperation1 for more information on using the InputService22TestCaseOperation1 4183// API call, and error handling. 4184// 4185// This method is useful when you want to inject custom logic or configuration 4186// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4187// 4188// 4189// // Example sending a request using the InputService22TestCaseOperation1Request method. 4190// req, resp := client.InputService22TestCaseOperation1Request(params) 4191// 4192// err := req.Send() 4193// if err == nil { // resp is now filled 4194// fmt.Println(resp) 4195// } 4196func (c *InputService22ProtocolTest) InputService22TestCaseOperation1Request(input *InputService22TestShapeInputService22TestCaseOperation1Input) (req *request.Request, output *InputService22TestShapeInputService22TestCaseOperation1Output) { 4197 op := &request.Operation{ 4198 Name: opInputService22TestCaseOperation1, 4199 HTTPMethod: "POST", 4200 HTTPPath: "/path", 4201 } 4202 4203 if input == nil { 4204 input = &InputService22TestShapeInputService22TestCaseOperation1Input{} 4205 } 4206 4207 output = &InputService22TestShapeInputService22TestCaseOperation1Output{} 4208 req = c.newRequest(op, input, output) 4209 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4210 return 4211} 4212 4213// InputService22TestCaseOperation1 API operation for . 4214// 4215// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4216// with awserr.Error's Code and Message methods to get detailed information about 4217// the error. 4218// 4219// See the AWS API reference guide for 's 4220// API operation InputService22TestCaseOperation1 for usage and error information. 4221func (c *InputService22ProtocolTest) InputService22TestCaseOperation1(input *InputService22TestShapeInputService22TestCaseOperation1Input) (*InputService22TestShapeInputService22TestCaseOperation1Output, error) { 4222 req, out := c.InputService22TestCaseOperation1Request(input) 4223 return out, req.Send() 4224} 4225 4226// InputService22TestCaseOperation1WithContext is the same as InputService22TestCaseOperation1 with the addition of 4227// the ability to pass a context and additional request options. 4228// 4229// See InputService22TestCaseOperation1 for details on how to use this API operation. 4230// 4231// The context must be non-nil and will be used for request cancellation. If 4232// the context is nil a panic will occur. In the future the SDK may create 4233// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4234// for more information on using Contexts. 4235func (c *InputService22ProtocolTest) InputService22TestCaseOperation1WithContext(ctx aws.Context, input *InputService22TestShapeInputService22TestCaseOperation1Input, opts ...request.Option) (*InputService22TestShapeInputService22TestCaseOperation1Output, error) { 4236 req, out := c.InputService22TestCaseOperation1Request(input) 4237 req.SetContext(ctx) 4238 req.ApplyOptions(opts...) 4239 return out, req.Send() 4240} 4241 4242const opInputService22TestCaseOperation2 = "OperationName" 4243 4244// InputService22TestCaseOperation2Request generates a "aws/request.Request" representing the 4245// client's request for the InputService22TestCaseOperation2 operation. The "output" return 4246// value will be populated with the request's response once the request completes 4247// successfully. 4248// 4249// Use "Send" method on the returned Request to send the API call to the service. 4250// the "output" return value is not valid until after Send returns without error. 4251// 4252// See InputService22TestCaseOperation2 for more information on using the InputService22TestCaseOperation2 4253// API call, and error handling. 4254// 4255// This method is useful when you want to inject custom logic or configuration 4256// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4257// 4258// 4259// // Example sending a request using the InputService22TestCaseOperation2Request method. 4260// req, resp := client.InputService22TestCaseOperation2Request(params) 4261// 4262// err := req.Send() 4263// if err == nil { // resp is now filled 4264// fmt.Println(resp) 4265// } 4266func (c *InputService22ProtocolTest) InputService22TestCaseOperation2Request(input *InputService22TestShapeInputService22TestCaseOperation2Input) (req *request.Request, output *InputService22TestShapeInputService22TestCaseOperation2Output) { 4267 op := &request.Operation{ 4268 Name: opInputService22TestCaseOperation2, 4269 HTTPMethod: "POST", 4270 HTTPPath: "/path?abc=mno", 4271 } 4272 4273 if input == nil { 4274 input = &InputService22TestShapeInputService22TestCaseOperation2Input{} 4275 } 4276 4277 output = &InputService22TestShapeInputService22TestCaseOperation2Output{} 4278 req = c.newRequest(op, input, output) 4279 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4280 return 4281} 4282 4283// InputService22TestCaseOperation2 API operation for . 4284// 4285// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4286// with awserr.Error's Code and Message methods to get detailed information about 4287// the error. 4288// 4289// See the AWS API reference guide for 's 4290// API operation InputService22TestCaseOperation2 for usage and error information. 4291func (c *InputService22ProtocolTest) InputService22TestCaseOperation2(input *InputService22TestShapeInputService22TestCaseOperation2Input) (*InputService22TestShapeInputService22TestCaseOperation2Output, error) { 4292 req, out := c.InputService22TestCaseOperation2Request(input) 4293 return out, req.Send() 4294} 4295 4296// InputService22TestCaseOperation2WithContext is the same as InputService22TestCaseOperation2 with the addition of 4297// the ability to pass a context and additional request options. 4298// 4299// See InputService22TestCaseOperation2 for details on how to use this API operation. 4300// 4301// The context must be non-nil and will be used for request cancellation. If 4302// the context is nil a panic will occur. In the future the SDK may create 4303// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4304// for more information on using Contexts. 4305func (c *InputService22ProtocolTest) InputService22TestCaseOperation2WithContext(ctx aws.Context, input *InputService22TestShapeInputService22TestCaseOperation2Input, opts ...request.Option) (*InputService22TestShapeInputService22TestCaseOperation2Output, error) { 4306 req, out := c.InputService22TestCaseOperation2Request(input) 4307 req.SetContext(ctx) 4308 req.ApplyOptions(opts...) 4309 return out, req.Send() 4310} 4311 4312type InputService22TestShapeInputService22TestCaseOperation1Input struct { 4313 _ struct{} `type:"structure"` 4314 4315 Foo *string `location:"querystring" locationName:"param-name" type:"string"` 4316} 4317 4318// SetFoo sets the Foo field's value. 4319func (s *InputService22TestShapeInputService22TestCaseOperation1Input) SetFoo(v string) *InputService22TestShapeInputService22TestCaseOperation1Input { 4320 s.Foo = &v 4321 return s 4322} 4323 4324type InputService22TestShapeInputService22TestCaseOperation1Output struct { 4325 _ struct{} `type:"structure"` 4326} 4327 4328type InputService22TestShapeInputService22TestCaseOperation2Input struct { 4329 _ struct{} `type:"structure"` 4330 4331 Foo *string `location:"querystring" locationName:"param-name" type:"string"` 4332} 4333 4334// SetFoo sets the Foo field's value. 4335func (s *InputService22TestShapeInputService22TestCaseOperation2Input) SetFoo(v string) *InputService22TestShapeInputService22TestCaseOperation2Input { 4336 s.Foo = &v 4337 return s 4338} 4339 4340type InputService22TestShapeInputService22TestCaseOperation2Output struct { 4341 _ struct{} `type:"structure"` 4342} 4343 4344// InputService23ProtocolTest provides the API operation methods for making requests to 4345// . See this package's package overview docs 4346// for details on the service. 4347// 4348// InputService23ProtocolTest methods are safe to use concurrently. It is not safe to 4349// modify mutate any of the struct's properties though. 4350type InputService23ProtocolTest struct { 4351 *client.Client 4352} 4353 4354// New creates a new instance of the InputService23ProtocolTest client with a session. 4355// If additional configuration is needed for the client instance use the optional 4356// aws.Config parameter to add your extra config. 4357// 4358// Example: 4359// // Create a InputService23ProtocolTest client from just a session. 4360// svc := inputservice23protocoltest.New(mySession) 4361// 4362// // Create a InputService23ProtocolTest client with additional configuration 4363// svc := inputservice23protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 4364func NewInputService23ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService23ProtocolTest { 4365 c := p.ClientConfig("inputservice23protocoltest", cfgs...) 4366 return newInputService23ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 4367} 4368 4369// newClient creates, initializes and returns a new service client instance. 4370func newInputService23ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService23ProtocolTest { 4371 svc := &InputService23ProtocolTest{ 4372 Client: client.New( 4373 cfg, 4374 metadata.ClientInfo{ 4375 ServiceName: "InputService23ProtocolTest", 4376 ServiceID: "InputService23ProtocolTest", 4377 SigningName: signingName, 4378 SigningRegion: signingRegion, 4379 Endpoint: endpoint, 4380 APIVersion: "2014-01-01", 4381 }, 4382 handlers, 4383 ), 4384 } 4385 4386 // Handlers 4387 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 4388 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 4389 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 4390 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 4391 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 4392 4393 return svc 4394} 4395 4396// newRequest creates a new request for a InputService23ProtocolTest operation and runs any 4397// custom request initialization. 4398func (c *InputService23ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 4399 req := c.NewRequest(op, params, data) 4400 4401 return req 4402} 4403 4404const opInputService23TestCaseOperation1 = "OperationName" 4405 4406// InputService23TestCaseOperation1Request generates a "aws/request.Request" representing the 4407// client's request for the InputService23TestCaseOperation1 operation. The "output" return 4408// value will be populated with the request's response once the request completes 4409// successfully. 4410// 4411// Use "Send" method on the returned Request to send the API call to the service. 4412// the "output" return value is not valid until after Send returns without error. 4413// 4414// See InputService23TestCaseOperation1 for more information on using the InputService23TestCaseOperation1 4415// API call, and error handling. 4416// 4417// This method is useful when you want to inject custom logic or configuration 4418// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4419// 4420// 4421// // Example sending a request using the InputService23TestCaseOperation1Request method. 4422// req, resp := client.InputService23TestCaseOperation1Request(params) 4423// 4424// err := req.Send() 4425// if err == nil { // resp is now filled 4426// fmt.Println(resp) 4427// } 4428func (c *InputService23ProtocolTest) InputService23TestCaseOperation1Request(input *InputService23TestShapeInputService23TestCaseOperation1Input) (req *request.Request, output *InputService23TestShapeInputService23TestCaseOperation1Output) { 4429 op := &request.Operation{ 4430 Name: opInputService23TestCaseOperation1, 4431 HTTPMethod: "POST", 4432 HTTPPath: "/path", 4433 } 4434 4435 if input == nil { 4436 input = &InputService23TestShapeInputService23TestCaseOperation1Input{} 4437 } 4438 4439 output = &InputService23TestShapeInputService23TestCaseOperation1Output{} 4440 req = c.newRequest(op, input, output) 4441 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4442 return 4443} 4444 4445// InputService23TestCaseOperation1 API operation for . 4446// 4447// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4448// with awserr.Error's Code and Message methods to get detailed information about 4449// the error. 4450// 4451// See the AWS API reference guide for 's 4452// API operation InputService23TestCaseOperation1 for usage and error information. 4453func (c *InputService23ProtocolTest) InputService23TestCaseOperation1(input *InputService23TestShapeInputService23TestCaseOperation1Input) (*InputService23TestShapeInputService23TestCaseOperation1Output, error) { 4454 req, out := c.InputService23TestCaseOperation1Request(input) 4455 return out, req.Send() 4456} 4457 4458// InputService23TestCaseOperation1WithContext is the same as InputService23TestCaseOperation1 with the addition of 4459// the ability to pass a context and additional request options. 4460// 4461// See InputService23TestCaseOperation1 for details on how to use this API operation. 4462// 4463// The context must be non-nil and will be used for request cancellation. If 4464// the context is nil a panic will occur. In the future the SDK may create 4465// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4466// for more information on using Contexts. 4467func (c *InputService23ProtocolTest) InputService23TestCaseOperation1WithContext(ctx aws.Context, input *InputService23TestShapeInputService23TestCaseOperation1Input, opts ...request.Option) (*InputService23TestShapeInputService23TestCaseOperation1Output, error) { 4468 req, out := c.InputService23TestCaseOperation1Request(input) 4469 req.SetContext(ctx) 4470 req.ApplyOptions(opts...) 4471 return out, req.Send() 4472} 4473 4474const opInputService23TestCaseOperation2 = "OperationName" 4475 4476// InputService23TestCaseOperation2Request generates a "aws/request.Request" representing the 4477// client's request for the InputService23TestCaseOperation2 operation. The "output" return 4478// value will be populated with the request's response once the request completes 4479// successfully. 4480// 4481// Use "Send" method on the returned Request to send the API call to the service. 4482// the "output" return value is not valid until after Send returns without error. 4483// 4484// See InputService23TestCaseOperation2 for more information on using the InputService23TestCaseOperation2 4485// API call, and error handling. 4486// 4487// This method is useful when you want to inject custom logic or configuration 4488// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4489// 4490// 4491// // Example sending a request using the InputService23TestCaseOperation2Request method. 4492// req, resp := client.InputService23TestCaseOperation2Request(params) 4493// 4494// err := req.Send() 4495// if err == nil { // resp is now filled 4496// fmt.Println(resp) 4497// } 4498func (c *InputService23ProtocolTest) InputService23TestCaseOperation2Request(input *InputService23TestShapeInputService23TestCaseOperation2Input) (req *request.Request, output *InputService23TestShapeInputService23TestCaseOperation2Output) { 4499 op := &request.Operation{ 4500 Name: opInputService23TestCaseOperation2, 4501 HTTPMethod: "POST", 4502 HTTPPath: "/path", 4503 } 4504 4505 if input == nil { 4506 input = &InputService23TestShapeInputService23TestCaseOperation2Input{} 4507 } 4508 4509 output = &InputService23TestShapeInputService23TestCaseOperation2Output{} 4510 req = c.newRequest(op, input, output) 4511 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4512 return 4513} 4514 4515// InputService23TestCaseOperation2 API operation for . 4516// 4517// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4518// with awserr.Error's Code and Message methods to get detailed information about 4519// the error. 4520// 4521// See the AWS API reference guide for 's 4522// API operation InputService23TestCaseOperation2 for usage and error information. 4523func (c *InputService23ProtocolTest) InputService23TestCaseOperation2(input *InputService23TestShapeInputService23TestCaseOperation2Input) (*InputService23TestShapeInputService23TestCaseOperation2Output, error) { 4524 req, out := c.InputService23TestCaseOperation2Request(input) 4525 return out, req.Send() 4526} 4527 4528// InputService23TestCaseOperation2WithContext is the same as InputService23TestCaseOperation2 with the addition of 4529// the ability to pass a context and additional request options. 4530// 4531// See InputService23TestCaseOperation2 for details on how to use this API operation. 4532// 4533// The context must be non-nil and will be used for request cancellation. If 4534// the context is nil a panic will occur. In the future the SDK may create 4535// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4536// for more information on using Contexts. 4537func (c *InputService23ProtocolTest) InputService23TestCaseOperation2WithContext(ctx aws.Context, input *InputService23TestShapeInputService23TestCaseOperation2Input, opts ...request.Option) (*InputService23TestShapeInputService23TestCaseOperation2Output, error) { 4538 req, out := c.InputService23TestCaseOperation2Request(input) 4539 req.SetContext(ctx) 4540 req.ApplyOptions(opts...) 4541 return out, req.Send() 4542} 4543 4544const opInputService23TestCaseOperation3 = "OperationName" 4545 4546// InputService23TestCaseOperation3Request generates a "aws/request.Request" representing the 4547// client's request for the InputService23TestCaseOperation3 operation. The "output" return 4548// value will be populated with the request's response once the request completes 4549// successfully. 4550// 4551// Use "Send" method on the returned Request to send the API call to the service. 4552// the "output" return value is not valid until after Send returns without error. 4553// 4554// See InputService23TestCaseOperation3 for more information on using the InputService23TestCaseOperation3 4555// API call, and error handling. 4556// 4557// This method is useful when you want to inject custom logic or configuration 4558// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4559// 4560// 4561// // Example sending a request using the InputService23TestCaseOperation3Request method. 4562// req, resp := client.InputService23TestCaseOperation3Request(params) 4563// 4564// err := req.Send() 4565// if err == nil { // resp is now filled 4566// fmt.Println(resp) 4567// } 4568func (c *InputService23ProtocolTest) InputService23TestCaseOperation3Request(input *InputService23TestShapeInputService23TestCaseOperation3Input) (req *request.Request, output *InputService23TestShapeInputService23TestCaseOperation3Output) { 4569 op := &request.Operation{ 4570 Name: opInputService23TestCaseOperation3, 4571 HTTPMethod: "POST", 4572 HTTPPath: "/path", 4573 } 4574 4575 if input == nil { 4576 input = &InputService23TestShapeInputService23TestCaseOperation3Input{} 4577 } 4578 4579 output = &InputService23TestShapeInputService23TestCaseOperation3Output{} 4580 req = c.newRequest(op, input, output) 4581 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4582 return 4583} 4584 4585// InputService23TestCaseOperation3 API operation for . 4586// 4587// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4588// with awserr.Error's Code and Message methods to get detailed information about 4589// the error. 4590// 4591// See the AWS API reference guide for 's 4592// API operation InputService23TestCaseOperation3 for usage and error information. 4593func (c *InputService23ProtocolTest) InputService23TestCaseOperation3(input *InputService23TestShapeInputService23TestCaseOperation3Input) (*InputService23TestShapeInputService23TestCaseOperation3Output, error) { 4594 req, out := c.InputService23TestCaseOperation3Request(input) 4595 return out, req.Send() 4596} 4597 4598// InputService23TestCaseOperation3WithContext is the same as InputService23TestCaseOperation3 with the addition of 4599// the ability to pass a context and additional request options. 4600// 4601// See InputService23TestCaseOperation3 for details on how to use this API operation. 4602// 4603// The context must be non-nil and will be used for request cancellation. If 4604// the context is nil a panic will occur. In the future the SDK may create 4605// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4606// for more information on using Contexts. 4607func (c *InputService23ProtocolTest) InputService23TestCaseOperation3WithContext(ctx aws.Context, input *InputService23TestShapeInputService23TestCaseOperation3Input, opts ...request.Option) (*InputService23TestShapeInputService23TestCaseOperation3Output, error) { 4608 req, out := c.InputService23TestCaseOperation3Request(input) 4609 req.SetContext(ctx) 4610 req.ApplyOptions(opts...) 4611 return out, req.Send() 4612} 4613 4614const opInputService23TestCaseOperation4 = "OperationName" 4615 4616// InputService23TestCaseOperation4Request generates a "aws/request.Request" representing the 4617// client's request for the InputService23TestCaseOperation4 operation. The "output" return 4618// value will be populated with the request's response once the request completes 4619// successfully. 4620// 4621// Use "Send" method on the returned Request to send the API call to the service. 4622// the "output" return value is not valid until after Send returns without error. 4623// 4624// See InputService23TestCaseOperation4 for more information on using the InputService23TestCaseOperation4 4625// API call, and error handling. 4626// 4627// This method is useful when you want to inject custom logic or configuration 4628// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4629// 4630// 4631// // Example sending a request using the InputService23TestCaseOperation4Request method. 4632// req, resp := client.InputService23TestCaseOperation4Request(params) 4633// 4634// err := req.Send() 4635// if err == nil { // resp is now filled 4636// fmt.Println(resp) 4637// } 4638func (c *InputService23ProtocolTest) InputService23TestCaseOperation4Request(input *InputService23TestShapeInputService23TestCaseOperation4Input) (req *request.Request, output *InputService23TestShapeInputService23TestCaseOperation4Output) { 4639 op := &request.Operation{ 4640 Name: opInputService23TestCaseOperation4, 4641 HTTPMethod: "POST", 4642 HTTPPath: "/path", 4643 } 4644 4645 if input == nil { 4646 input = &InputService23TestShapeInputService23TestCaseOperation4Input{} 4647 } 4648 4649 output = &InputService23TestShapeInputService23TestCaseOperation4Output{} 4650 req = c.newRequest(op, input, output) 4651 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4652 return 4653} 4654 4655// InputService23TestCaseOperation4 API operation for . 4656// 4657// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4658// with awserr.Error's Code and Message methods to get detailed information about 4659// the error. 4660// 4661// See the AWS API reference guide for 's 4662// API operation InputService23TestCaseOperation4 for usage and error information. 4663func (c *InputService23ProtocolTest) InputService23TestCaseOperation4(input *InputService23TestShapeInputService23TestCaseOperation4Input) (*InputService23TestShapeInputService23TestCaseOperation4Output, error) { 4664 req, out := c.InputService23TestCaseOperation4Request(input) 4665 return out, req.Send() 4666} 4667 4668// InputService23TestCaseOperation4WithContext is the same as InputService23TestCaseOperation4 with the addition of 4669// the ability to pass a context and additional request options. 4670// 4671// See InputService23TestCaseOperation4 for details on how to use this API operation. 4672// 4673// The context must be non-nil and will be used for request cancellation. If 4674// the context is nil a panic will occur. In the future the SDK may create 4675// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4676// for more information on using Contexts. 4677func (c *InputService23ProtocolTest) InputService23TestCaseOperation4WithContext(ctx aws.Context, input *InputService23TestShapeInputService23TestCaseOperation4Input, opts ...request.Option) (*InputService23TestShapeInputService23TestCaseOperation4Output, error) { 4678 req, out := c.InputService23TestCaseOperation4Request(input) 4679 req.SetContext(ctx) 4680 req.ApplyOptions(opts...) 4681 return out, req.Send() 4682} 4683 4684const opInputService23TestCaseOperation5 = "OperationName" 4685 4686// InputService23TestCaseOperation5Request generates a "aws/request.Request" representing the 4687// client's request for the InputService23TestCaseOperation5 operation. The "output" return 4688// value will be populated with the request's response once the request completes 4689// successfully. 4690// 4691// Use "Send" method on the returned Request to send the API call to the service. 4692// the "output" return value is not valid until after Send returns without error. 4693// 4694// See InputService23TestCaseOperation5 for more information on using the InputService23TestCaseOperation5 4695// API call, and error handling. 4696// 4697// This method is useful when you want to inject custom logic or configuration 4698// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4699// 4700// 4701// // Example sending a request using the InputService23TestCaseOperation5Request method. 4702// req, resp := client.InputService23TestCaseOperation5Request(params) 4703// 4704// err := req.Send() 4705// if err == nil { // resp is now filled 4706// fmt.Println(resp) 4707// } 4708func (c *InputService23ProtocolTest) InputService23TestCaseOperation5Request(input *InputService23TestShapeInputService23TestCaseOperation5Input) (req *request.Request, output *InputService23TestShapeInputService23TestCaseOperation5Output) { 4709 op := &request.Operation{ 4710 Name: opInputService23TestCaseOperation5, 4711 HTTPMethod: "POST", 4712 HTTPPath: "/path", 4713 } 4714 4715 if input == nil { 4716 input = &InputService23TestShapeInputService23TestCaseOperation5Input{} 4717 } 4718 4719 output = &InputService23TestShapeInputService23TestCaseOperation5Output{} 4720 req = c.newRequest(op, input, output) 4721 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4722 return 4723} 4724 4725// InputService23TestCaseOperation5 API operation for . 4726// 4727// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4728// with awserr.Error's Code and Message methods to get detailed information about 4729// the error. 4730// 4731// See the AWS API reference guide for 's 4732// API operation InputService23TestCaseOperation5 for usage and error information. 4733func (c *InputService23ProtocolTest) InputService23TestCaseOperation5(input *InputService23TestShapeInputService23TestCaseOperation5Input) (*InputService23TestShapeInputService23TestCaseOperation5Output, error) { 4734 req, out := c.InputService23TestCaseOperation5Request(input) 4735 return out, req.Send() 4736} 4737 4738// InputService23TestCaseOperation5WithContext is the same as InputService23TestCaseOperation5 with the addition of 4739// the ability to pass a context and additional request options. 4740// 4741// See InputService23TestCaseOperation5 for details on how to use this API operation. 4742// 4743// The context must be non-nil and will be used for request cancellation. If 4744// the context is nil a panic will occur. In the future the SDK may create 4745// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4746// for more information on using Contexts. 4747func (c *InputService23ProtocolTest) InputService23TestCaseOperation5WithContext(ctx aws.Context, input *InputService23TestShapeInputService23TestCaseOperation5Input, opts ...request.Option) (*InputService23TestShapeInputService23TestCaseOperation5Output, error) { 4748 req, out := c.InputService23TestCaseOperation5Request(input) 4749 req.SetContext(ctx) 4750 req.ApplyOptions(opts...) 4751 return out, req.Send() 4752} 4753 4754const opInputService23TestCaseOperation6 = "OperationName" 4755 4756// InputService23TestCaseOperation6Request generates a "aws/request.Request" representing the 4757// client's request for the InputService23TestCaseOperation6 operation. The "output" return 4758// value will be populated with the request's response once the request completes 4759// successfully. 4760// 4761// Use "Send" method on the returned Request to send the API call to the service. 4762// the "output" return value is not valid until after Send returns without error. 4763// 4764// See InputService23TestCaseOperation6 for more information on using the InputService23TestCaseOperation6 4765// API call, and error handling. 4766// 4767// This method is useful when you want to inject custom logic or configuration 4768// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4769// 4770// 4771// // Example sending a request using the InputService23TestCaseOperation6Request method. 4772// req, resp := client.InputService23TestCaseOperation6Request(params) 4773// 4774// err := req.Send() 4775// if err == nil { // resp is now filled 4776// fmt.Println(resp) 4777// } 4778func (c *InputService23ProtocolTest) InputService23TestCaseOperation6Request(input *InputService23TestShapeInputService23TestCaseOperation6Input) (req *request.Request, output *InputService23TestShapeInputService23TestCaseOperation6Output) { 4779 op := &request.Operation{ 4780 Name: opInputService23TestCaseOperation6, 4781 HTTPMethod: "POST", 4782 HTTPPath: "/path", 4783 } 4784 4785 if input == nil { 4786 input = &InputService23TestShapeInputService23TestCaseOperation6Input{} 4787 } 4788 4789 output = &InputService23TestShapeInputService23TestCaseOperation6Output{} 4790 req = c.newRequest(op, input, output) 4791 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 4792 return 4793} 4794 4795// InputService23TestCaseOperation6 API operation for . 4796// 4797// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4798// with awserr.Error's Code and Message methods to get detailed information about 4799// the error. 4800// 4801// See the AWS API reference guide for 's 4802// API operation InputService23TestCaseOperation6 for usage and error information. 4803func (c *InputService23ProtocolTest) InputService23TestCaseOperation6(input *InputService23TestShapeInputService23TestCaseOperation6Input) (*InputService23TestShapeInputService23TestCaseOperation6Output, error) { 4804 req, out := c.InputService23TestCaseOperation6Request(input) 4805 return out, req.Send() 4806} 4807 4808// InputService23TestCaseOperation6WithContext is the same as InputService23TestCaseOperation6 with the addition of 4809// the ability to pass a context and additional request options. 4810// 4811// See InputService23TestCaseOperation6 for details on how to use this API operation. 4812// 4813// The context must be non-nil and will be used for request cancellation. If 4814// the context is nil a panic will occur. In the future the SDK may create 4815// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4816// for more information on using Contexts. 4817func (c *InputService23ProtocolTest) InputService23TestCaseOperation6WithContext(ctx aws.Context, input *InputService23TestShapeInputService23TestCaseOperation6Input, opts ...request.Option) (*InputService23TestShapeInputService23TestCaseOperation6Output, error) { 4818 req, out := c.InputService23TestCaseOperation6Request(input) 4819 req.SetContext(ctx) 4820 req.ApplyOptions(opts...) 4821 return out, req.Send() 4822} 4823 4824type InputService23TestShapeInputService23TestCaseOperation1Input struct { 4825 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 4826 4827 RecursiveStruct *InputService23TestShapeRecursiveStructType `type:"structure"` 4828} 4829 4830// SetRecursiveStruct sets the RecursiveStruct field's value. 4831func (s *InputService23TestShapeInputService23TestCaseOperation1Input) SetRecursiveStruct(v *InputService23TestShapeRecursiveStructType) *InputService23TestShapeInputService23TestCaseOperation1Input { 4832 s.RecursiveStruct = v 4833 return s 4834} 4835 4836type InputService23TestShapeInputService23TestCaseOperation1Output struct { 4837 _ struct{} `type:"structure"` 4838} 4839 4840type InputService23TestShapeInputService23TestCaseOperation2Input struct { 4841 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 4842 4843 RecursiveStruct *InputService23TestShapeRecursiveStructType `type:"structure"` 4844} 4845 4846// SetRecursiveStruct sets the RecursiveStruct field's value. 4847func (s *InputService23TestShapeInputService23TestCaseOperation2Input) SetRecursiveStruct(v *InputService23TestShapeRecursiveStructType) *InputService23TestShapeInputService23TestCaseOperation2Input { 4848 s.RecursiveStruct = v 4849 return s 4850} 4851 4852type InputService23TestShapeInputService23TestCaseOperation2Output struct { 4853 _ struct{} `type:"structure"` 4854} 4855 4856type InputService23TestShapeInputService23TestCaseOperation3Input struct { 4857 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 4858 4859 RecursiveStruct *InputService23TestShapeRecursiveStructType `type:"structure"` 4860} 4861 4862// SetRecursiveStruct sets the RecursiveStruct field's value. 4863func (s *InputService23TestShapeInputService23TestCaseOperation3Input) SetRecursiveStruct(v *InputService23TestShapeRecursiveStructType) *InputService23TestShapeInputService23TestCaseOperation3Input { 4864 s.RecursiveStruct = v 4865 return s 4866} 4867 4868type InputService23TestShapeInputService23TestCaseOperation3Output struct { 4869 _ struct{} `type:"structure"` 4870} 4871 4872type InputService23TestShapeInputService23TestCaseOperation4Input struct { 4873 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 4874 4875 RecursiveStruct *InputService23TestShapeRecursiveStructType `type:"structure"` 4876} 4877 4878// SetRecursiveStruct sets the RecursiveStruct field's value. 4879func (s *InputService23TestShapeInputService23TestCaseOperation4Input) SetRecursiveStruct(v *InputService23TestShapeRecursiveStructType) *InputService23TestShapeInputService23TestCaseOperation4Input { 4880 s.RecursiveStruct = v 4881 return s 4882} 4883 4884type InputService23TestShapeInputService23TestCaseOperation4Output struct { 4885 _ struct{} `type:"structure"` 4886} 4887 4888type InputService23TestShapeInputService23TestCaseOperation5Input struct { 4889 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 4890 4891 RecursiveStruct *InputService23TestShapeRecursiveStructType `type:"structure"` 4892} 4893 4894// SetRecursiveStruct sets the RecursiveStruct field's value. 4895func (s *InputService23TestShapeInputService23TestCaseOperation5Input) SetRecursiveStruct(v *InputService23TestShapeRecursiveStructType) *InputService23TestShapeInputService23TestCaseOperation5Input { 4896 s.RecursiveStruct = v 4897 return s 4898} 4899 4900type InputService23TestShapeInputService23TestCaseOperation5Output struct { 4901 _ struct{} `type:"structure"` 4902} 4903 4904type InputService23TestShapeInputService23TestCaseOperation6Input struct { 4905 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 4906 4907 RecursiveStruct *InputService23TestShapeRecursiveStructType `type:"structure"` 4908} 4909 4910// SetRecursiveStruct sets the RecursiveStruct field's value. 4911func (s *InputService23TestShapeInputService23TestCaseOperation6Input) SetRecursiveStruct(v *InputService23TestShapeRecursiveStructType) *InputService23TestShapeInputService23TestCaseOperation6Input { 4912 s.RecursiveStruct = v 4913 return s 4914} 4915 4916type InputService23TestShapeInputService23TestCaseOperation6Output struct { 4917 _ struct{} `type:"structure"` 4918} 4919 4920type InputService23TestShapeRecursiveStructType struct { 4921 _ struct{} `type:"structure"` 4922 4923 NoRecurse *string `type:"string"` 4924 4925 RecursiveList []*InputService23TestShapeRecursiveStructType `type:"list"` 4926 4927 RecursiveMap map[string]*InputService23TestShapeRecursiveStructType `type:"map"` 4928 4929 RecursiveStruct *InputService23TestShapeRecursiveStructType `type:"structure"` 4930} 4931 4932// SetNoRecurse sets the NoRecurse field's value. 4933func (s *InputService23TestShapeRecursiveStructType) SetNoRecurse(v string) *InputService23TestShapeRecursiveStructType { 4934 s.NoRecurse = &v 4935 return s 4936} 4937 4938// SetRecursiveList sets the RecursiveList field's value. 4939func (s *InputService23TestShapeRecursiveStructType) SetRecursiveList(v []*InputService23TestShapeRecursiveStructType) *InputService23TestShapeRecursiveStructType { 4940 s.RecursiveList = v 4941 return s 4942} 4943 4944// SetRecursiveMap sets the RecursiveMap field's value. 4945func (s *InputService23TestShapeRecursiveStructType) SetRecursiveMap(v map[string]*InputService23TestShapeRecursiveStructType) *InputService23TestShapeRecursiveStructType { 4946 s.RecursiveMap = v 4947 return s 4948} 4949 4950// SetRecursiveStruct sets the RecursiveStruct field's value. 4951func (s *InputService23TestShapeRecursiveStructType) SetRecursiveStruct(v *InputService23TestShapeRecursiveStructType) *InputService23TestShapeRecursiveStructType { 4952 s.RecursiveStruct = v 4953 return s 4954} 4955 4956// InputService24ProtocolTest provides the API operation methods for making requests to 4957// . See this package's package overview docs 4958// for details on the service. 4959// 4960// InputService24ProtocolTest methods are safe to use concurrently. It is not safe to 4961// modify mutate any of the struct's properties though. 4962type InputService24ProtocolTest struct { 4963 *client.Client 4964} 4965 4966// New creates a new instance of the InputService24ProtocolTest client with a session. 4967// If additional configuration is needed for the client instance use the optional 4968// aws.Config parameter to add your extra config. 4969// 4970// Example: 4971// // Create a InputService24ProtocolTest client from just a session. 4972// svc := inputservice24protocoltest.New(mySession) 4973// 4974// // Create a InputService24ProtocolTest client with additional configuration 4975// svc := inputservice24protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 4976func NewInputService24ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService24ProtocolTest { 4977 c := p.ClientConfig("inputservice24protocoltest", cfgs...) 4978 return newInputService24ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 4979} 4980 4981// newClient creates, initializes and returns a new service client instance. 4982func newInputService24ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService24ProtocolTest { 4983 svc := &InputService24ProtocolTest{ 4984 Client: client.New( 4985 cfg, 4986 metadata.ClientInfo{ 4987 ServiceName: "InputService24ProtocolTest", 4988 ServiceID: "InputService24ProtocolTest", 4989 SigningName: signingName, 4990 SigningRegion: signingRegion, 4991 Endpoint: endpoint, 4992 APIVersion: "2014-01-01", 4993 }, 4994 handlers, 4995 ), 4996 } 4997 4998 // Handlers 4999 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 5000 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 5001 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 5002 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 5003 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 5004 5005 return svc 5006} 5007 5008// newRequest creates a new request for a InputService24ProtocolTest operation and runs any 5009// custom request initialization. 5010func (c *InputService24ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 5011 req := c.NewRequest(op, params, data) 5012 5013 return req 5014} 5015 5016const opInputService24TestCaseOperation1 = "OperationName" 5017 5018// InputService24TestCaseOperation1Request generates a "aws/request.Request" representing the 5019// client's request for the InputService24TestCaseOperation1 operation. The "output" return 5020// value will be populated with the request's response once the request completes 5021// successfully. 5022// 5023// Use "Send" method on the returned Request to send the API call to the service. 5024// the "output" return value is not valid until after Send returns without error. 5025// 5026// See InputService24TestCaseOperation1 for more information on using the InputService24TestCaseOperation1 5027// API call, and error handling. 5028// 5029// This method is useful when you want to inject custom logic or configuration 5030// into the SDK's request lifecycle. Such as custom headers, or retry logic. 5031// 5032// 5033// // Example sending a request using the InputService24TestCaseOperation1Request method. 5034// req, resp := client.InputService24TestCaseOperation1Request(params) 5035// 5036// err := req.Send() 5037// if err == nil { // resp is now filled 5038// fmt.Println(resp) 5039// } 5040func (c *InputService24ProtocolTest) InputService24TestCaseOperation1Request(input *InputService24TestShapeInputService24TestCaseOperation1Input) (req *request.Request, output *InputService24TestShapeInputService24TestCaseOperation1Output) { 5041 op := &request.Operation{ 5042 Name: opInputService24TestCaseOperation1, 5043 HTTPMethod: "POST", 5044 HTTPPath: "/path", 5045 } 5046 5047 if input == nil { 5048 input = &InputService24TestShapeInputService24TestCaseOperation1Input{} 5049 } 5050 5051 output = &InputService24TestShapeInputService24TestCaseOperation1Output{} 5052 req = c.newRequest(op, input, output) 5053 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 5054 return 5055} 5056 5057// InputService24TestCaseOperation1 API operation for . 5058// 5059// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 5060// with awserr.Error's Code and Message methods to get detailed information about 5061// the error. 5062// 5063// See the AWS API reference guide for 's 5064// API operation InputService24TestCaseOperation1 for usage and error information. 5065func (c *InputService24ProtocolTest) InputService24TestCaseOperation1(input *InputService24TestShapeInputService24TestCaseOperation1Input) (*InputService24TestShapeInputService24TestCaseOperation1Output, error) { 5066 req, out := c.InputService24TestCaseOperation1Request(input) 5067 return out, req.Send() 5068} 5069 5070// InputService24TestCaseOperation1WithContext is the same as InputService24TestCaseOperation1 with the addition of 5071// the ability to pass a context and additional request options. 5072// 5073// See InputService24TestCaseOperation1 for details on how to use this API operation. 5074// 5075// The context must be non-nil and will be used for request cancellation. If 5076// the context is nil a panic will occur. In the future the SDK may create 5077// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 5078// for more information on using Contexts. 5079func (c *InputService24ProtocolTest) InputService24TestCaseOperation1WithContext(ctx aws.Context, input *InputService24TestShapeInputService24TestCaseOperation1Input, opts ...request.Option) (*InputService24TestShapeInputService24TestCaseOperation1Output, error) { 5080 req, out := c.InputService24TestCaseOperation1Request(input) 5081 req.SetContext(ctx) 5082 req.ApplyOptions(opts...) 5083 return out, req.Send() 5084} 5085 5086const opInputService24TestCaseOperation2 = "OperationName" 5087 5088// InputService24TestCaseOperation2Request generates a "aws/request.Request" representing the 5089// client's request for the InputService24TestCaseOperation2 operation. The "output" return 5090// value will be populated with the request's response once the request completes 5091// successfully. 5092// 5093// Use "Send" method on the returned Request to send the API call to the service. 5094// the "output" return value is not valid until after Send returns without error. 5095// 5096// See InputService24TestCaseOperation2 for more information on using the InputService24TestCaseOperation2 5097// API call, and error handling. 5098// 5099// This method is useful when you want to inject custom logic or configuration 5100// into the SDK's request lifecycle. Such as custom headers, or retry logic. 5101// 5102// 5103// // Example sending a request using the InputService24TestCaseOperation2Request method. 5104// req, resp := client.InputService24TestCaseOperation2Request(params) 5105// 5106// err := req.Send() 5107// if err == nil { // resp is now filled 5108// fmt.Println(resp) 5109// } 5110func (c *InputService24ProtocolTest) InputService24TestCaseOperation2Request(input *InputService24TestShapeInputService24TestCaseOperation2Input) (req *request.Request, output *InputService24TestShapeInputService24TestCaseOperation2Output) { 5111 op := &request.Operation{ 5112 Name: opInputService24TestCaseOperation2, 5113 HTTPMethod: "POST", 5114 HTTPPath: "/path", 5115 } 5116 5117 if input == nil { 5118 input = &InputService24TestShapeInputService24TestCaseOperation2Input{} 5119 } 5120 5121 output = &InputService24TestShapeInputService24TestCaseOperation2Output{} 5122 req = c.newRequest(op, input, output) 5123 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 5124 return 5125} 5126 5127// InputService24TestCaseOperation2 API operation for . 5128// 5129// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 5130// with awserr.Error's Code and Message methods to get detailed information about 5131// the error. 5132// 5133// See the AWS API reference guide for 's 5134// API operation InputService24TestCaseOperation2 for usage and error information. 5135func (c *InputService24ProtocolTest) InputService24TestCaseOperation2(input *InputService24TestShapeInputService24TestCaseOperation2Input) (*InputService24TestShapeInputService24TestCaseOperation2Output, error) { 5136 req, out := c.InputService24TestCaseOperation2Request(input) 5137 return out, req.Send() 5138} 5139 5140// InputService24TestCaseOperation2WithContext is the same as InputService24TestCaseOperation2 with the addition of 5141// the ability to pass a context and additional request options. 5142// 5143// See InputService24TestCaseOperation2 for details on how to use this API operation. 5144// 5145// The context must be non-nil and will be used for request cancellation. If 5146// the context is nil a panic will occur. In the future the SDK may create 5147// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 5148// for more information on using Contexts. 5149func (c *InputService24ProtocolTest) InputService24TestCaseOperation2WithContext(ctx aws.Context, input *InputService24TestShapeInputService24TestCaseOperation2Input, opts ...request.Option) (*InputService24TestShapeInputService24TestCaseOperation2Output, error) { 5150 req, out := c.InputService24TestCaseOperation2Request(input) 5151 req.SetContext(ctx) 5152 req.ApplyOptions(opts...) 5153 return out, req.Send() 5154} 5155 5156type InputService24TestShapeInputService24TestCaseOperation1Input struct { 5157 _ struct{} `type:"structure"` 5158 5159 Token *string `type:"string" idempotencyToken:"true"` 5160} 5161 5162// SetToken sets the Token field's value. 5163func (s *InputService24TestShapeInputService24TestCaseOperation1Input) SetToken(v string) *InputService24TestShapeInputService24TestCaseOperation1Input { 5164 s.Token = &v 5165 return s 5166} 5167 5168type InputService24TestShapeInputService24TestCaseOperation1Output struct { 5169 _ struct{} `type:"structure"` 5170} 5171 5172type InputService24TestShapeInputService24TestCaseOperation2Input struct { 5173 _ struct{} `type:"structure"` 5174 5175 Token *string `type:"string" idempotencyToken:"true"` 5176} 5177 5178// SetToken sets the Token field's value. 5179func (s *InputService24TestShapeInputService24TestCaseOperation2Input) SetToken(v string) *InputService24TestShapeInputService24TestCaseOperation2Input { 5180 s.Token = &v 5181 return s 5182} 5183 5184type InputService24TestShapeInputService24TestCaseOperation2Output struct { 5185 _ struct{} `type:"structure"` 5186} 5187 5188// InputService25ProtocolTest provides the API operation methods for making requests to 5189// . See this package's package overview docs 5190// for details on the service. 5191// 5192// InputService25ProtocolTest methods are safe to use concurrently. It is not safe to 5193// modify mutate any of the struct's properties though. 5194type InputService25ProtocolTest struct { 5195 *client.Client 5196} 5197 5198// New creates a new instance of the InputService25ProtocolTest client with a session. 5199// If additional configuration is needed for the client instance use the optional 5200// aws.Config parameter to add your extra config. 5201// 5202// Example: 5203// // Create a InputService25ProtocolTest client from just a session. 5204// svc := inputservice25protocoltest.New(mySession) 5205// 5206// // Create a InputService25ProtocolTest client with additional configuration 5207// svc := inputservice25protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 5208func NewInputService25ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService25ProtocolTest { 5209 c := p.ClientConfig("inputservice25protocoltest", cfgs...) 5210 return newInputService25ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 5211} 5212 5213// newClient creates, initializes and returns a new service client instance. 5214func newInputService25ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService25ProtocolTest { 5215 svc := &InputService25ProtocolTest{ 5216 Client: client.New( 5217 cfg, 5218 metadata.ClientInfo{ 5219 ServiceName: "InputService25ProtocolTest", 5220 ServiceID: "InputService25ProtocolTest", 5221 SigningName: signingName, 5222 SigningRegion: signingRegion, 5223 Endpoint: endpoint, 5224 APIVersion: "2014-01-01", 5225 }, 5226 handlers, 5227 ), 5228 } 5229 5230 // Handlers 5231 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 5232 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 5233 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 5234 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 5235 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 5236 5237 return svc 5238} 5239 5240// newRequest creates a new request for a InputService25ProtocolTest operation and runs any 5241// custom request initialization. 5242func (c *InputService25ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 5243 req := c.NewRequest(op, params, data) 5244 5245 return req 5246} 5247 5248const opInputService25TestCaseOperation1 = "OperationName" 5249 5250// InputService25TestCaseOperation1Request generates a "aws/request.Request" representing the 5251// client's request for the InputService25TestCaseOperation1 operation. The "output" return 5252// value will be populated with the request's response once the request completes 5253// successfully. 5254// 5255// Use "Send" method on the returned Request to send the API call to the service. 5256// the "output" return value is not valid until after Send returns without error. 5257// 5258// See InputService25TestCaseOperation1 for more information on using the InputService25TestCaseOperation1 5259// API call, and error handling. 5260// 5261// This method is useful when you want to inject custom logic or configuration 5262// into the SDK's request lifecycle. Such as custom headers, or retry logic. 5263// 5264// 5265// // Example sending a request using the InputService25TestCaseOperation1Request method. 5266// req, resp := client.InputService25TestCaseOperation1Request(params) 5267// 5268// err := req.Send() 5269// if err == nil { // resp is now filled 5270// fmt.Println(resp) 5271// } 5272func (c *InputService25ProtocolTest) InputService25TestCaseOperation1Request(input *InputService25TestShapeInputService25TestCaseOperation1Input) (req *request.Request, output *InputService25TestShapeInputService25TestCaseOperation1Output) { 5273 op := &request.Operation{ 5274 Name: opInputService25TestCaseOperation1, 5275 HTTPMethod: "POST", 5276 HTTPPath: "/Enum/{URIEnum}", 5277 } 5278 5279 if input == nil { 5280 input = &InputService25TestShapeInputService25TestCaseOperation1Input{} 5281 } 5282 5283 output = &InputService25TestShapeInputService25TestCaseOperation1Output{} 5284 req = c.newRequest(op, input, output) 5285 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 5286 return 5287} 5288 5289// InputService25TestCaseOperation1 API operation for . 5290// 5291// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 5292// with awserr.Error's Code and Message methods to get detailed information about 5293// the error. 5294// 5295// See the AWS API reference guide for 's 5296// API operation InputService25TestCaseOperation1 for usage and error information. 5297func (c *InputService25ProtocolTest) InputService25TestCaseOperation1(input *InputService25TestShapeInputService25TestCaseOperation1Input) (*InputService25TestShapeInputService25TestCaseOperation1Output, error) { 5298 req, out := c.InputService25TestCaseOperation1Request(input) 5299 return out, req.Send() 5300} 5301 5302// InputService25TestCaseOperation1WithContext is the same as InputService25TestCaseOperation1 with the addition of 5303// the ability to pass a context and additional request options. 5304// 5305// See InputService25TestCaseOperation1 for details on how to use this API operation. 5306// 5307// The context must be non-nil and will be used for request cancellation. If 5308// the context is nil a panic will occur. In the future the SDK may create 5309// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 5310// for more information on using Contexts. 5311func (c *InputService25ProtocolTest) InputService25TestCaseOperation1WithContext(ctx aws.Context, input *InputService25TestShapeInputService25TestCaseOperation1Input, opts ...request.Option) (*InputService25TestShapeInputService25TestCaseOperation1Output, error) { 5312 req, out := c.InputService25TestCaseOperation1Request(input) 5313 req.SetContext(ctx) 5314 req.ApplyOptions(opts...) 5315 return out, req.Send() 5316} 5317 5318const opInputService25TestCaseOperation2 = "OperationName" 5319 5320// InputService25TestCaseOperation2Request generates a "aws/request.Request" representing the 5321// client's request for the InputService25TestCaseOperation2 operation. The "output" return 5322// value will be populated with the request's response once the request completes 5323// successfully. 5324// 5325// Use "Send" method on the returned Request to send the API call to the service. 5326// the "output" return value is not valid until after Send returns without error. 5327// 5328// See InputService25TestCaseOperation2 for more information on using the InputService25TestCaseOperation2 5329// API call, and error handling. 5330// 5331// This method is useful when you want to inject custom logic or configuration 5332// into the SDK's request lifecycle. Such as custom headers, or retry logic. 5333// 5334// 5335// // Example sending a request using the InputService25TestCaseOperation2Request method. 5336// req, resp := client.InputService25TestCaseOperation2Request(params) 5337// 5338// err := req.Send() 5339// if err == nil { // resp is now filled 5340// fmt.Println(resp) 5341// } 5342func (c *InputService25ProtocolTest) InputService25TestCaseOperation2Request(input *InputService25TestShapeInputService25TestCaseOperation2Input) (req *request.Request, output *InputService25TestShapeInputService25TestCaseOperation2Output) { 5343 op := &request.Operation{ 5344 Name: opInputService25TestCaseOperation2, 5345 HTTPMethod: "POST", 5346 HTTPPath: "/Enum/{URIEnum}", 5347 } 5348 5349 if input == nil { 5350 input = &InputService25TestShapeInputService25TestCaseOperation2Input{} 5351 } 5352 5353 output = &InputService25TestShapeInputService25TestCaseOperation2Output{} 5354 req = c.newRequest(op, input, output) 5355 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 5356 return 5357} 5358 5359// InputService25TestCaseOperation2 API operation for . 5360// 5361// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 5362// with awserr.Error's Code and Message methods to get detailed information about 5363// the error. 5364// 5365// See the AWS API reference guide for 's 5366// API operation InputService25TestCaseOperation2 for usage and error information. 5367func (c *InputService25ProtocolTest) InputService25TestCaseOperation2(input *InputService25TestShapeInputService25TestCaseOperation2Input) (*InputService25TestShapeInputService25TestCaseOperation2Output, error) { 5368 req, out := c.InputService25TestCaseOperation2Request(input) 5369 return out, req.Send() 5370} 5371 5372// InputService25TestCaseOperation2WithContext is the same as InputService25TestCaseOperation2 with the addition of 5373// the ability to pass a context and additional request options. 5374// 5375// See InputService25TestCaseOperation2 for details on how to use this API operation. 5376// 5377// The context must be non-nil and will be used for request cancellation. If 5378// the context is nil a panic will occur. In the future the SDK may create 5379// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 5380// for more information on using Contexts. 5381func (c *InputService25ProtocolTest) InputService25TestCaseOperation2WithContext(ctx aws.Context, input *InputService25TestShapeInputService25TestCaseOperation2Input, opts ...request.Option) (*InputService25TestShapeInputService25TestCaseOperation2Output, error) { 5382 req, out := c.InputService25TestCaseOperation2Request(input) 5383 req.SetContext(ctx) 5384 req.ApplyOptions(opts...) 5385 return out, req.Send() 5386} 5387 5388type InputService25TestShapeInputService25TestCaseOperation1Input struct { 5389 _ struct{} `type:"structure"` 5390 5391 FooEnum *string `type:"string" enum:"InputService25TestShapeEnumType"` 5392 5393 HeaderEnum *string `location:"header" locationName:"x-amz-enum" type:"string" enum:"InputService25TestShapeEnumType"` 5394 5395 ListEnums []*string `type:"list"` 5396 5397 // URIFooEnum is a required field 5398 URIFooEnum *string `location:"uri" locationName:"URIEnum" type:"string" required:"true" enum:"InputService25TestShapeEnumType"` 5399 5400 URIListEnums []*string `location:"querystring" locationName:"ListEnums" type:"list"` 5401} 5402 5403// Validate inspects the fields of the type to determine if they are valid. 5404func (s *InputService25TestShapeInputService25TestCaseOperation1Input) Validate() error { 5405 invalidParams := request.ErrInvalidParams{Context: "InputService25TestShapeInputService25TestCaseOperation1Input"} 5406 if s.URIFooEnum == nil { 5407 invalidParams.Add(request.NewErrParamRequired("URIFooEnum")) 5408 } 5409 if s.URIFooEnum != nil && len(*s.URIFooEnum) < 1 { 5410 invalidParams.Add(request.NewErrParamMinLen("URIFooEnum", 1)) 5411 } 5412 5413 if invalidParams.Len() > 0 { 5414 return invalidParams 5415 } 5416 return nil 5417} 5418 5419// SetFooEnum sets the FooEnum field's value. 5420func (s *InputService25TestShapeInputService25TestCaseOperation1Input) SetFooEnum(v string) *InputService25TestShapeInputService25TestCaseOperation1Input { 5421 s.FooEnum = &v 5422 return s 5423} 5424 5425// SetHeaderEnum sets the HeaderEnum field's value. 5426func (s *InputService25TestShapeInputService25TestCaseOperation1Input) SetHeaderEnum(v string) *InputService25TestShapeInputService25TestCaseOperation1Input { 5427 s.HeaderEnum = &v 5428 return s 5429} 5430 5431// SetListEnums sets the ListEnums field's value. 5432func (s *InputService25TestShapeInputService25TestCaseOperation1Input) SetListEnums(v []*string) *InputService25TestShapeInputService25TestCaseOperation1Input { 5433 s.ListEnums = v 5434 return s 5435} 5436 5437// SetURIFooEnum sets the URIFooEnum field's value. 5438func (s *InputService25TestShapeInputService25TestCaseOperation1Input) SetURIFooEnum(v string) *InputService25TestShapeInputService25TestCaseOperation1Input { 5439 s.URIFooEnum = &v 5440 return s 5441} 5442 5443// SetURIListEnums sets the URIListEnums field's value. 5444func (s *InputService25TestShapeInputService25TestCaseOperation1Input) SetURIListEnums(v []*string) *InputService25TestShapeInputService25TestCaseOperation1Input { 5445 s.URIListEnums = v 5446 return s 5447} 5448 5449type InputService25TestShapeInputService25TestCaseOperation1Output struct { 5450 _ struct{} `type:"structure"` 5451} 5452 5453type InputService25TestShapeInputService25TestCaseOperation2Input struct { 5454 _ struct{} `type:"structure"` 5455 5456 FooEnum *string `type:"string" enum:"InputService25TestShapeEnumType"` 5457 5458 HeaderEnum *string `location:"header" locationName:"x-amz-enum" type:"string" enum:"InputService25TestShapeEnumType"` 5459 5460 ListEnums []*string `type:"list"` 5461 5462 // URIFooEnum is a required field 5463 URIFooEnum *string `location:"uri" locationName:"URIEnum" type:"string" required:"true" enum:"InputService25TestShapeEnumType"` 5464 5465 URIListEnums []*string `location:"querystring" locationName:"ListEnums" type:"list"` 5466} 5467 5468// Validate inspects the fields of the type to determine if they are valid. 5469func (s *InputService25TestShapeInputService25TestCaseOperation2Input) Validate() error { 5470 invalidParams := request.ErrInvalidParams{Context: "InputService25TestShapeInputService25TestCaseOperation2Input"} 5471 if s.URIFooEnum == nil { 5472 invalidParams.Add(request.NewErrParamRequired("URIFooEnum")) 5473 } 5474 if s.URIFooEnum != nil && len(*s.URIFooEnum) < 1 { 5475 invalidParams.Add(request.NewErrParamMinLen("URIFooEnum", 1)) 5476 } 5477 5478 if invalidParams.Len() > 0 { 5479 return invalidParams 5480 } 5481 return nil 5482} 5483 5484// SetFooEnum sets the FooEnum field's value. 5485func (s *InputService25TestShapeInputService25TestCaseOperation2Input) SetFooEnum(v string) *InputService25TestShapeInputService25TestCaseOperation2Input { 5486 s.FooEnum = &v 5487 return s 5488} 5489 5490// SetHeaderEnum sets the HeaderEnum field's value. 5491func (s *InputService25TestShapeInputService25TestCaseOperation2Input) SetHeaderEnum(v string) *InputService25TestShapeInputService25TestCaseOperation2Input { 5492 s.HeaderEnum = &v 5493 return s 5494} 5495 5496// SetListEnums sets the ListEnums field's value. 5497func (s *InputService25TestShapeInputService25TestCaseOperation2Input) SetListEnums(v []*string) *InputService25TestShapeInputService25TestCaseOperation2Input { 5498 s.ListEnums = v 5499 return s 5500} 5501 5502// SetURIFooEnum sets the URIFooEnum field's value. 5503func (s *InputService25TestShapeInputService25TestCaseOperation2Input) SetURIFooEnum(v string) *InputService25TestShapeInputService25TestCaseOperation2Input { 5504 s.URIFooEnum = &v 5505 return s 5506} 5507 5508// SetURIListEnums sets the URIListEnums field's value. 5509func (s *InputService25TestShapeInputService25TestCaseOperation2Input) SetURIListEnums(v []*string) *InputService25TestShapeInputService25TestCaseOperation2Input { 5510 s.URIListEnums = v 5511 return s 5512} 5513 5514type InputService25TestShapeInputService25TestCaseOperation2Output struct { 5515 _ struct{} `type:"structure"` 5516} 5517 5518const ( 5519 // EnumTypeFoo is a InputService25TestShapeEnumType enum value 5520 EnumTypeFoo = "foo" 5521 5522 // EnumTypeBar is a InputService25TestShapeEnumType enum value 5523 EnumTypeBar = "bar" 5524 5525 // EnumType0 is a InputService25TestShapeEnumType enum value 5526 EnumType0 = "0" 5527 5528 // EnumType1 is a InputService25TestShapeEnumType enum value 5529 EnumType1 = "1" 5530) 5531 5532// InputService26ProtocolTest provides the API operation methods for making requests to 5533// . See this package's package overview docs 5534// for details on the service. 5535// 5536// InputService26ProtocolTest methods are safe to use concurrently. It is not safe to 5537// modify mutate any of the struct's properties though. 5538type InputService26ProtocolTest struct { 5539 *client.Client 5540} 5541 5542// New creates a new instance of the InputService26ProtocolTest client with a session. 5543// If additional configuration is needed for the client instance use the optional 5544// aws.Config parameter to add your extra config. 5545// 5546// Example: 5547// // Create a InputService26ProtocolTest client from just a session. 5548// svc := inputservice26protocoltest.New(mySession) 5549// 5550// // Create a InputService26ProtocolTest client with additional configuration 5551// svc := inputservice26protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 5552func NewInputService26ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService26ProtocolTest { 5553 c := p.ClientConfig("inputservice26protocoltest", cfgs...) 5554 return newInputService26ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 5555} 5556 5557// newClient creates, initializes and returns a new service client instance. 5558func newInputService26ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService26ProtocolTest { 5559 svc := &InputService26ProtocolTest{ 5560 Client: client.New( 5561 cfg, 5562 metadata.ClientInfo{ 5563 ServiceName: "InputService26ProtocolTest", 5564 ServiceID: "InputService26ProtocolTest", 5565 SigningName: signingName, 5566 SigningRegion: signingRegion, 5567 Endpoint: endpoint, 5568 APIVersion: "2014-01-01", 5569 }, 5570 handlers, 5571 ), 5572 } 5573 5574 // Handlers 5575 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 5576 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 5577 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 5578 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 5579 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 5580 5581 return svc 5582} 5583 5584// newRequest creates a new request for a InputService26ProtocolTest operation and runs any 5585// custom request initialization. 5586func (c *InputService26ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 5587 req := c.NewRequest(op, params, data) 5588 5589 return req 5590} 5591 5592const opInputService26TestCaseOperation1 = "StaticOp" 5593 5594// InputService26TestCaseOperation1Request generates a "aws/request.Request" representing the 5595// client's request for the InputService26TestCaseOperation1 operation. The "output" return 5596// value will be populated with the request's response once the request completes 5597// successfully. 5598// 5599// Use "Send" method on the returned Request to send the API call to the service. 5600// the "output" return value is not valid until after Send returns without error. 5601// 5602// See InputService26TestCaseOperation1 for more information on using the InputService26TestCaseOperation1 5603// API call, and error handling. 5604// 5605// This method is useful when you want to inject custom logic or configuration 5606// into the SDK's request lifecycle. Such as custom headers, or retry logic. 5607// 5608// 5609// // Example sending a request using the InputService26TestCaseOperation1Request method. 5610// req, resp := client.InputService26TestCaseOperation1Request(params) 5611// 5612// err := req.Send() 5613// if err == nil { // resp is now filled 5614// fmt.Println(resp) 5615// } 5616func (c *InputService26ProtocolTest) InputService26TestCaseOperation1Request(input *InputService26TestShapeInputService26TestCaseOperation1Input) (req *request.Request, output *InputService26TestShapeInputService26TestCaseOperation1Output) { 5617 op := &request.Operation{ 5618 Name: opInputService26TestCaseOperation1, 5619 HTTPMethod: "POST", 5620 HTTPPath: "/path", 5621 } 5622 5623 if input == nil { 5624 input = &InputService26TestShapeInputService26TestCaseOperation1Input{} 5625 } 5626 5627 output = &InputService26TestShapeInputService26TestCaseOperation1Output{} 5628 req = c.newRequest(op, input, output) 5629 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 5630 req.Handlers.Build.PushBackNamed(protocol.NewHostPrefixHandler("data-", nil)) 5631 req.Handlers.Build.PushBackNamed(protocol.ValidateEndpointHostHandler) 5632 return 5633} 5634 5635// InputService26TestCaseOperation1 API operation for . 5636// 5637// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 5638// with awserr.Error's Code and Message methods to get detailed information about 5639// the error. 5640// 5641// See the AWS API reference guide for 's 5642// API operation InputService26TestCaseOperation1 for usage and error information. 5643func (c *InputService26ProtocolTest) InputService26TestCaseOperation1(input *InputService26TestShapeInputService26TestCaseOperation1Input) (*InputService26TestShapeInputService26TestCaseOperation1Output, error) { 5644 req, out := c.InputService26TestCaseOperation1Request(input) 5645 return out, req.Send() 5646} 5647 5648// InputService26TestCaseOperation1WithContext is the same as InputService26TestCaseOperation1 with the addition of 5649// the ability to pass a context and additional request options. 5650// 5651// See InputService26TestCaseOperation1 for details on how to use this API operation. 5652// 5653// The context must be non-nil and will be used for request cancellation. If 5654// the context is nil a panic will occur. In the future the SDK may create 5655// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 5656// for more information on using Contexts. 5657func (c *InputService26ProtocolTest) InputService26TestCaseOperation1WithContext(ctx aws.Context, input *InputService26TestShapeInputService26TestCaseOperation1Input, opts ...request.Option) (*InputService26TestShapeInputService26TestCaseOperation1Output, error) { 5658 req, out := c.InputService26TestCaseOperation1Request(input) 5659 req.SetContext(ctx) 5660 req.ApplyOptions(opts...) 5661 return out, req.Send() 5662} 5663 5664const opInputService26TestCaseOperation2 = "MemberRefOp" 5665 5666// InputService26TestCaseOperation2Request generates a "aws/request.Request" representing the 5667// client's request for the InputService26TestCaseOperation2 operation. The "output" return 5668// value will be populated with the request's response once the request completes 5669// successfully. 5670// 5671// Use "Send" method on the returned Request to send the API call to the service. 5672// the "output" return value is not valid until after Send returns without error. 5673// 5674// See InputService26TestCaseOperation2 for more information on using the InputService26TestCaseOperation2 5675// API call, and error handling. 5676// 5677// This method is useful when you want to inject custom logic or configuration 5678// into the SDK's request lifecycle. Such as custom headers, or retry logic. 5679// 5680// 5681// // Example sending a request using the InputService26TestCaseOperation2Request method. 5682// req, resp := client.InputService26TestCaseOperation2Request(params) 5683// 5684// err := req.Send() 5685// if err == nil { // resp is now filled 5686// fmt.Println(resp) 5687// } 5688func (c *InputService26ProtocolTest) InputService26TestCaseOperation2Request(input *InputService26TestShapeInputService26TestCaseOperation2Input) (req *request.Request, output *InputService26TestShapeInputService26TestCaseOperation2Output) { 5689 op := &request.Operation{ 5690 Name: opInputService26TestCaseOperation2, 5691 HTTPMethod: "POST", 5692 HTTPPath: "/path", 5693 } 5694 5695 if input == nil { 5696 input = &InputService26TestShapeInputService26TestCaseOperation2Input{} 5697 } 5698 5699 output = &InputService26TestShapeInputService26TestCaseOperation2Output{} 5700 req = c.newRequest(op, input, output) 5701 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 5702 req.Handlers.Build.PushBackNamed(protocol.NewHostPrefixHandler("foo-{Name}.", input.hostLabels)) 5703 req.Handlers.Build.PushBackNamed(protocol.ValidateEndpointHostHandler) 5704 return 5705} 5706 5707// InputService26TestCaseOperation2 API operation for . 5708// 5709// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 5710// with awserr.Error's Code and Message methods to get detailed information about 5711// the error. 5712// 5713// See the AWS API reference guide for 's 5714// API operation InputService26TestCaseOperation2 for usage and error information. 5715func (c *InputService26ProtocolTest) InputService26TestCaseOperation2(input *InputService26TestShapeInputService26TestCaseOperation2Input) (*InputService26TestShapeInputService26TestCaseOperation2Output, error) { 5716 req, out := c.InputService26TestCaseOperation2Request(input) 5717 return out, req.Send() 5718} 5719 5720// InputService26TestCaseOperation2WithContext is the same as InputService26TestCaseOperation2 with the addition of 5721// the ability to pass a context and additional request options. 5722// 5723// See InputService26TestCaseOperation2 for details on how to use this API operation. 5724// 5725// The context must be non-nil and will be used for request cancellation. If 5726// the context is nil a panic will occur. In the future the SDK may create 5727// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 5728// for more information on using Contexts. 5729func (c *InputService26ProtocolTest) InputService26TestCaseOperation2WithContext(ctx aws.Context, input *InputService26TestShapeInputService26TestCaseOperation2Input, opts ...request.Option) (*InputService26TestShapeInputService26TestCaseOperation2Output, error) { 5730 req, out := c.InputService26TestCaseOperation2Request(input) 5731 req.SetContext(ctx) 5732 req.ApplyOptions(opts...) 5733 return out, req.Send() 5734} 5735 5736type InputService26TestShapeInputService26TestCaseOperation1Input struct { 5737 _ struct{} `locationName:"StaticOpRequest" type:"structure"` 5738 5739 Name *string `type:"string"` 5740} 5741 5742// SetName sets the Name field's value. 5743func (s *InputService26TestShapeInputService26TestCaseOperation1Input) SetName(v string) *InputService26TestShapeInputService26TestCaseOperation1Input { 5744 s.Name = &v 5745 return s 5746} 5747 5748type InputService26TestShapeInputService26TestCaseOperation1Output struct { 5749 _ struct{} `type:"structure"` 5750} 5751 5752type InputService26TestShapeInputService26TestCaseOperation2Input struct { 5753 _ struct{} `locationName:"MemberRefOpRequest" type:"structure"` 5754 5755 // Name is a required field 5756 Name *string `type:"string" required:"true"` 5757} 5758 5759// Validate inspects the fields of the type to determine if they are valid. 5760func (s *InputService26TestShapeInputService26TestCaseOperation2Input) Validate() error { 5761 invalidParams := request.ErrInvalidParams{Context: "InputService26TestShapeInputService26TestCaseOperation2Input"} 5762 if s.Name == nil { 5763 invalidParams.Add(request.NewErrParamRequired("Name")) 5764 } 5765 if s.Name != nil && len(*s.Name) < 1 { 5766 invalidParams.Add(request.NewErrParamMinLen("Name", 1)) 5767 } 5768 5769 if invalidParams.Len() > 0 { 5770 return invalidParams 5771 } 5772 return nil 5773} 5774 5775// SetName sets the Name field's value. 5776func (s *InputService26TestShapeInputService26TestCaseOperation2Input) SetName(v string) *InputService26TestShapeInputService26TestCaseOperation2Input { 5777 s.Name = &v 5778 return s 5779} 5780 5781func (s *InputService26TestShapeInputService26TestCaseOperation2Input) hostLabels() map[string]string { 5782 return map[string]string{ 5783 "Name": aws.StringValue(s.Name), 5784 } 5785} 5786 5787type InputService26TestShapeInputService26TestCaseOperation2Output struct { 5788 _ struct{} `type:"structure"` 5789} 5790 5791// InputService27ProtocolTest provides the API operation methods for making requests to 5792// . See this package's package overview docs 5793// for details on the service. 5794// 5795// InputService27ProtocolTest methods are safe to use concurrently. It is not safe to 5796// modify mutate any of the struct's properties though. 5797type InputService27ProtocolTest struct { 5798 *client.Client 5799} 5800 5801// New creates a new instance of the InputService27ProtocolTest client with a session. 5802// If additional configuration is needed for the client instance use the optional 5803// aws.Config parameter to add your extra config. 5804// 5805// Example: 5806// // Create a InputService27ProtocolTest client from just a session. 5807// svc := inputservice27protocoltest.New(mySession) 5808// 5809// // Create a InputService27ProtocolTest client with additional configuration 5810// svc := inputservice27protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 5811func NewInputService27ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService27ProtocolTest { 5812 c := p.ClientConfig("inputservice27protocoltest", cfgs...) 5813 return newInputService27ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 5814} 5815 5816// newClient creates, initializes and returns a new service client instance. 5817func newInputService27ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService27ProtocolTest { 5818 svc := &InputService27ProtocolTest{ 5819 Client: client.New( 5820 cfg, 5821 metadata.ClientInfo{ 5822 ServiceName: "InputService27ProtocolTest", 5823 ServiceID: "InputService27ProtocolTest", 5824 SigningName: signingName, 5825 SigningRegion: signingRegion, 5826 Endpoint: endpoint, 5827 APIVersion: "2014-01-01", 5828 }, 5829 handlers, 5830 ), 5831 } 5832 5833 // Handlers 5834 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 5835 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 5836 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 5837 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 5838 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 5839 5840 return svc 5841} 5842 5843// newRequest creates a new request for a InputService27ProtocolTest operation and runs any 5844// custom request initialization. 5845func (c *InputService27ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 5846 req := c.NewRequest(op, params, data) 5847 5848 return req 5849} 5850 5851const opInputService27TestCaseOperation1 = "OperationName" 5852 5853// InputService27TestCaseOperation1Request generates a "aws/request.Request" representing the 5854// client's request for the InputService27TestCaseOperation1 operation. The "output" return 5855// value will be populated with the request's response once the request completes 5856// successfully. 5857// 5858// Use "Send" method on the returned Request to send the API call to the service. 5859// the "output" return value is not valid until after Send returns without error. 5860// 5861// See InputService27TestCaseOperation1 for more information on using the InputService27TestCaseOperation1 5862// API call, and error handling. 5863// 5864// This method is useful when you want to inject custom logic or configuration 5865// into the SDK's request lifecycle. Such as custom headers, or retry logic. 5866// 5867// 5868// // Example sending a request using the InputService27TestCaseOperation1Request method. 5869// req, resp := client.InputService27TestCaseOperation1Request(params) 5870// 5871// err := req.Send() 5872// if err == nil { // resp is now filled 5873// fmt.Println(resp) 5874// } 5875func (c *InputService27ProtocolTest) InputService27TestCaseOperation1Request(input *InputService27TestShapeInputService27TestCaseOperation1Input) (req *request.Request, output *InputService27TestShapeInputService27TestCaseOperation1Output) { 5876 op := &request.Operation{ 5877 Name: opInputService27TestCaseOperation1, 5878 HTTPMethod: "GET", 5879 HTTPPath: "/", 5880 } 5881 5882 if input == nil { 5883 input = &InputService27TestShapeInputService27TestCaseOperation1Input{} 5884 } 5885 5886 output = &InputService27TestShapeInputService27TestCaseOperation1Output{} 5887 req = c.newRequest(op, input, output) 5888 req.Handlers.Unmarshal.Swap(restxml.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 5889 return 5890} 5891 5892// InputService27TestCaseOperation1 API operation for . 5893// 5894// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 5895// with awserr.Error's Code and Message methods to get detailed information about 5896// the error. 5897// 5898// See the AWS API reference guide for 's 5899// API operation InputService27TestCaseOperation1 for usage and error information. 5900func (c *InputService27ProtocolTest) InputService27TestCaseOperation1(input *InputService27TestShapeInputService27TestCaseOperation1Input) (*InputService27TestShapeInputService27TestCaseOperation1Output, error) { 5901 req, out := c.InputService27TestCaseOperation1Request(input) 5902 return out, req.Send() 5903} 5904 5905// InputService27TestCaseOperation1WithContext is the same as InputService27TestCaseOperation1 with the addition of 5906// the ability to pass a context and additional request options. 5907// 5908// See InputService27TestCaseOperation1 for details on how to use this API operation. 5909// 5910// The context must be non-nil and will be used for request cancellation. If 5911// the context is nil a panic will occur. In the future the SDK may create 5912// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 5913// for more information on using Contexts. 5914func (c *InputService27ProtocolTest) InputService27TestCaseOperation1WithContext(ctx aws.Context, input *InputService27TestShapeInputService27TestCaseOperation1Input, opts ...request.Option) (*InputService27TestShapeInputService27TestCaseOperation1Output, error) { 5915 req, out := c.InputService27TestCaseOperation1Request(input) 5916 req.SetContext(ctx) 5917 req.ApplyOptions(opts...) 5918 return out, req.Send() 5919} 5920 5921type InputService27TestShapeInputService27TestCaseOperation1Input struct { 5922 _ struct{} `type:"structure"` 5923 5924 Header1 *string `location:"header" type:"string"` 5925 5926 HeaderMap map[string]*string `location:"headers" locationName:"header-map-" type:"map"` 5927} 5928 5929// SetHeader1 sets the Header1 field's value. 5930func (s *InputService27TestShapeInputService27TestCaseOperation1Input) SetHeader1(v string) *InputService27TestShapeInputService27TestCaseOperation1Input { 5931 s.Header1 = &v 5932 return s 5933} 5934 5935// SetHeaderMap sets the HeaderMap field's value. 5936func (s *InputService27TestShapeInputService27TestCaseOperation1Input) SetHeaderMap(v map[string]*string) *InputService27TestShapeInputService27TestCaseOperation1Input { 5937 s.HeaderMap = v 5938 return s 5939} 5940 5941type InputService27TestShapeInputService27TestCaseOperation1Output struct { 5942 _ struct{} `type:"structure"` 5943} 5944 5945// 5946// Tests begin here 5947// 5948 5949func TestInputService1ProtocolTestBasicXMLSerializationCase1(t *testing.T) { 5950 svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5951 input := &InputService1TestShapeInputService1TestCaseOperation1Input{ 5952 Description: aws.String("bar"), 5953 Name: aws.String("foo"), 5954 } 5955 req, _ := svc.InputService1TestCaseOperation1Request(input) 5956 r := req.HTTPRequest 5957 5958 // build request 5959 req.Build() 5960 if req.Error != nil { 5961 t.Errorf("expect no error, got %v", req.Error) 5962 } 5963 5964 // assert body 5965 if r.Body == nil { 5966 t.Errorf("expect body not to be nil") 5967 } 5968 body := util.SortXML(r.Body) 5969 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><Description xmlns="https://foo/">bar</Description><Name xmlns="https://foo/">foo</Name></OperationRequest>`, util.Trim(string(body)), InputService1TestShapeInputService1TestCaseOperation1Input{}) 5970 5971 // assert URL 5972 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 5973 5974 // assert headers 5975 5976} 5977 5978func TestInputService1ProtocolTestBasicXMLSerializationCase2(t *testing.T) { 5979 svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5980 input := &InputService1TestShapeInputService1TestCaseOperation2Input{ 5981 Description: aws.String("bar"), 5982 Name: aws.String("foo"), 5983 } 5984 req, _ := svc.InputService1TestCaseOperation2Request(input) 5985 r := req.HTTPRequest 5986 5987 // build request 5988 req.Build() 5989 if req.Error != nil { 5990 t.Errorf("expect no error, got %v", req.Error) 5991 } 5992 5993 // assert body 5994 if r.Body == nil { 5995 t.Errorf("expect body not to be nil") 5996 } 5997 body := util.SortXML(r.Body) 5998 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><Description xmlns="https://foo/">bar</Description><Name xmlns="https://foo/">foo</Name></OperationRequest>`, util.Trim(string(body)), InputService1TestShapeInputService1TestCaseOperation2Input{}) 5999 6000 // assert URL 6001 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 6002 6003 // assert headers 6004 6005} 6006 6007func TestInputService1ProtocolTestBasicXMLSerializationCase3(t *testing.T) { 6008 svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6009 input := &InputService1TestShapeInputService1TestCaseOperation3Input{} 6010 req, _ := svc.InputService1TestCaseOperation3Request(input) 6011 r := req.HTTPRequest 6012 6013 // build request 6014 req.Build() 6015 if req.Error != nil { 6016 t.Errorf("expect no error, got %v", req.Error) 6017 } 6018 6019 // assert URL 6020 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 6021 6022 // assert headers 6023 6024} 6025 6026func TestInputService2ProtocolTestSerializeOtherScalarTypesCase1(t *testing.T) { 6027 svc := NewInputService2ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6028 input := &InputService2TestShapeInputService2TestCaseOperation1Input{ 6029 First: aws.Bool(true), 6030 Fourth: aws.Int64(3), 6031 Second: aws.Bool(false), 6032 Third: aws.Float64(1.2), 6033 } 6034 req, _ := svc.InputService2TestCaseOperation1Request(input) 6035 r := req.HTTPRequest 6036 6037 // build request 6038 req.Build() 6039 if req.Error != nil { 6040 t.Errorf("expect no error, got %v", req.Error) 6041 } 6042 6043 // assert body 6044 if r.Body == nil { 6045 t.Errorf("expect body not to be nil") 6046 } 6047 body := util.SortXML(r.Body) 6048 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><First xmlns="https://foo/">true</First><Fourth xmlns="https://foo/">3</Fourth><Second xmlns="https://foo/">false</Second><Third xmlns="https://foo/">1.2</Third></OperationRequest>`, util.Trim(string(body)), InputService2TestShapeInputService2TestCaseOperation1Input{}) 6049 6050 // assert URL 6051 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 6052 6053 // assert headers 6054 6055} 6056 6057func TestInputService3ProtocolTestNestedStructuresCase1(t *testing.T) { 6058 svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6059 input := &InputService3TestShapeInputService3TestCaseOperation1Input{ 6060 Description: aws.String("baz"), 6061 SubStructure: &InputService3TestShapeSubStructure{ 6062 Bar: aws.String("b"), 6063 Foo: aws.String("a"), 6064 }, 6065 } 6066 req, _ := svc.InputService3TestCaseOperation1Request(input) 6067 r := req.HTTPRequest 6068 6069 // build request 6070 req.Build() 6071 if req.Error != nil { 6072 t.Errorf("expect no error, got %v", req.Error) 6073 } 6074 6075 // assert body 6076 if r.Body == nil { 6077 t.Errorf("expect body not to be nil") 6078 } 6079 body := util.SortXML(r.Body) 6080 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><Description xmlns="https://foo/">baz</Description><SubStructure xmlns="https://foo/"><Bar xmlns="https://foo/">b</Bar><Foo xmlns="https://foo/">a</Foo></SubStructure></OperationRequest>`, util.Trim(string(body)), InputService3TestShapeInputService3TestCaseOperation1Input{}) 6081 6082 // assert URL 6083 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 6084 6085 // assert headers 6086 6087} 6088 6089func TestInputService3ProtocolTestNestedStructuresCase2(t *testing.T) { 6090 svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6091 input := &InputService3TestShapeInputService3TestCaseOperation2Input{ 6092 Description: aws.String("baz"), 6093 SubStructure: &InputService3TestShapeSubStructure{ 6094 Foo: aws.String("a"), 6095 }, 6096 } 6097 req, _ := svc.InputService3TestCaseOperation2Request(input) 6098 r := req.HTTPRequest 6099 6100 // build request 6101 req.Build() 6102 if req.Error != nil { 6103 t.Errorf("expect no error, got %v", req.Error) 6104 } 6105 6106 // assert body 6107 if r.Body == nil { 6108 t.Errorf("expect body not to be nil") 6109 } 6110 body := util.SortXML(r.Body) 6111 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><Description xmlns="https://foo/">baz</Description><SubStructure xmlns="https://foo/"><Foo xmlns="https://foo/">a</Foo></SubStructure></OperationRequest>`, util.Trim(string(body)), InputService3TestShapeInputService3TestCaseOperation2Input{}) 6112 6113 // assert URL 6114 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 6115 6116 // assert headers 6117 6118} 6119 6120func TestInputService4ProtocolTestNestedStructuresCase1(t *testing.T) { 6121 svc := NewInputService4ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6122 input := &InputService4TestShapeInputService4TestCaseOperation1Input{ 6123 Description: aws.String("baz"), 6124 SubStructure: &InputService4TestShapeSubStructure{}, 6125 } 6126 req, _ := svc.InputService4TestCaseOperation1Request(input) 6127 r := req.HTTPRequest 6128 6129 // build request 6130 req.Build() 6131 if req.Error != nil { 6132 t.Errorf("expect no error, got %v", req.Error) 6133 } 6134 6135 // assert body 6136 if r.Body == nil { 6137 t.Errorf("expect body not to be nil") 6138 } 6139 body := util.SortXML(r.Body) 6140 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><Description xmlns="https://foo/">baz</Description><SubStructure xmlns="https://foo/"></SubStructure></OperationRequest>`, util.Trim(string(body)), InputService4TestShapeInputService4TestCaseOperation1Input{}) 6141 6142 // assert URL 6143 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 6144 6145 // assert headers 6146 6147} 6148 6149func TestInputService5ProtocolTestNonFlattenedListsCase1(t *testing.T) { 6150 svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6151 input := &InputService5TestShapeInputService5TestCaseOperation1Input{ 6152 ListParam: []*string{ 6153 aws.String("one"), 6154 aws.String("two"), 6155 aws.String("three"), 6156 }, 6157 } 6158 req, _ := svc.InputService5TestCaseOperation1Request(input) 6159 r := req.HTTPRequest 6160 6161 // build request 6162 req.Build() 6163 if req.Error != nil { 6164 t.Errorf("expect no error, got %v", req.Error) 6165 } 6166 6167 // assert body 6168 if r.Body == nil { 6169 t.Errorf("expect body not to be nil") 6170 } 6171 body := util.SortXML(r.Body) 6172 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><ListParam xmlns="https://foo/"><member xmlns="https://foo/">one</member><member xmlns="https://foo/">two</member><member xmlns="https://foo/">three</member></ListParam></OperationRequest>`, util.Trim(string(body)), InputService5TestShapeInputService5TestCaseOperation1Input{}) 6173 6174 // assert URL 6175 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 6176 6177 // assert headers 6178 6179} 6180 6181func TestInputService6ProtocolTestNonFlattenedListsWithLocationNameCase1(t *testing.T) { 6182 svc := NewInputService6ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6183 input := &InputService6TestShapeInputService6TestCaseOperation1Input{ 6184 ListParam: []*string{ 6185 aws.String("one"), 6186 aws.String("two"), 6187 aws.String("three"), 6188 }, 6189 } 6190 req, _ := svc.InputService6TestCaseOperation1Request(input) 6191 r := req.HTTPRequest 6192 6193 // build request 6194 req.Build() 6195 if req.Error != nil { 6196 t.Errorf("expect no error, got %v", req.Error) 6197 } 6198 6199 // assert body 6200 if r.Body == nil { 6201 t.Errorf("expect body not to be nil") 6202 } 6203 body := util.SortXML(r.Body) 6204 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><AlternateName xmlns="https://foo/"><NotMember xmlns="https://foo/">one</NotMember><NotMember xmlns="https://foo/">two</NotMember><NotMember xmlns="https://foo/">three</NotMember></AlternateName></OperationRequest>`, util.Trim(string(body)), InputService6TestShapeInputService6TestCaseOperation1Input{}) 6205 6206 // assert URL 6207 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 6208 6209 // assert headers 6210 6211} 6212 6213func TestInputService7ProtocolTestFlattenedListsCase1(t *testing.T) { 6214 svc := NewInputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6215 input := &InputService7TestShapeInputService7TestCaseOperation1Input{ 6216 ListParam: []*string{ 6217 aws.String("one"), 6218 aws.String("two"), 6219 aws.String("three"), 6220 }, 6221 } 6222 req, _ := svc.InputService7TestCaseOperation1Request(input) 6223 r := req.HTTPRequest 6224 6225 // build request 6226 req.Build() 6227 if req.Error != nil { 6228 t.Errorf("expect no error, got %v", req.Error) 6229 } 6230 6231 // assert body 6232 if r.Body == nil { 6233 t.Errorf("expect body not to be nil") 6234 } 6235 body := util.SortXML(r.Body) 6236 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><ListParam xmlns="https://foo/">one</ListParam><ListParam xmlns="https://foo/">two</ListParam><ListParam xmlns="https://foo/">three</ListParam></OperationRequest>`, util.Trim(string(body)), InputService7TestShapeInputService7TestCaseOperation1Input{}) 6237 6238 // assert URL 6239 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 6240 6241 // assert headers 6242 6243} 6244 6245func TestInputService8ProtocolTestFlattenedListsWithLocationNameCase1(t *testing.T) { 6246 svc := NewInputService8ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6247 input := &InputService8TestShapeInputService8TestCaseOperation1Input{ 6248 ListParam: []*string{ 6249 aws.String("one"), 6250 aws.String("two"), 6251 aws.String("three"), 6252 }, 6253 } 6254 req, _ := svc.InputService8TestCaseOperation1Request(input) 6255 r := req.HTTPRequest 6256 6257 // build request 6258 req.Build() 6259 if req.Error != nil { 6260 t.Errorf("expect no error, got %v", req.Error) 6261 } 6262 6263 // assert body 6264 if r.Body == nil { 6265 t.Errorf("expect body not to be nil") 6266 } 6267 body := util.SortXML(r.Body) 6268 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><item xmlns="https://foo/">one</item><item xmlns="https://foo/">two</item><item xmlns="https://foo/">three</item></OperationRequest>`, util.Trim(string(body)), InputService8TestShapeInputService8TestCaseOperation1Input{}) 6269 6270 // assert URL 6271 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 6272 6273 // assert headers 6274 6275} 6276 6277func TestInputService9ProtocolTestListOfStructuresCase1(t *testing.T) { 6278 svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6279 input := &InputService9TestShapeInputService9TestCaseOperation1Input{ 6280 ListParam: []*InputService9TestShapeSingleFieldStruct{ 6281 { 6282 Element: aws.String("one"), 6283 }, 6284 { 6285 Element: aws.String("two"), 6286 }, 6287 { 6288 Element: aws.String("three"), 6289 }, 6290 }, 6291 } 6292 req, _ := svc.InputService9TestCaseOperation1Request(input) 6293 r := req.HTTPRequest 6294 6295 // build request 6296 req.Build() 6297 if req.Error != nil { 6298 t.Errorf("expect no error, got %v", req.Error) 6299 } 6300 6301 // assert body 6302 if r.Body == nil { 6303 t.Errorf("expect body not to be nil") 6304 } 6305 body := util.SortXML(r.Body) 6306 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><item xmlns="https://foo/"><value xmlns="https://foo/">one</value></item><item xmlns="https://foo/"><value xmlns="https://foo/">two</value></item><item xmlns="https://foo/"><value xmlns="https://foo/">three</value></item></OperationRequest>`, util.Trim(string(body)), InputService9TestShapeInputService9TestCaseOperation1Input{}) 6307 6308 // assert URL 6309 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 6310 6311 // assert headers 6312 6313} 6314 6315func TestInputService10ProtocolTestBlobShapesCase1(t *testing.T) { 6316 svc := NewInputService10ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6317 input := &InputService10TestShapeInputService10TestCaseOperation1Input{ 6318 StructureParam: &InputService10TestShapeStructureShape{ 6319 B: []byte("foo"), 6320 }, 6321 } 6322 req, _ := svc.InputService10TestCaseOperation1Request(input) 6323 r := req.HTTPRequest 6324 6325 // build request 6326 req.Build() 6327 if req.Error != nil { 6328 t.Errorf("expect no error, got %v", req.Error) 6329 } 6330 6331 // assert body 6332 if r.Body == nil { 6333 t.Errorf("expect body not to be nil") 6334 } 6335 body := util.SortXML(r.Body) 6336 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><StructureParam xmlns="https://foo/"><b xmlns="https://foo/">Zm9v</b></StructureParam></OperationRequest>`, util.Trim(string(body)), InputService10TestShapeInputService10TestCaseOperation1Input{}) 6337 6338 // assert URL 6339 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 6340 6341 // assert headers 6342 6343} 6344 6345func TestInputService11ProtocolTestTimestampShapesCase1(t *testing.T) { 6346 svc := NewInputService11ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6347 input := &InputService11TestShapeInputService11TestCaseOperation1Input{ 6348 TimeArg: aws.Time(time.Unix(1422172800, 0)), 6349 TimeArgInHeader: aws.Time(time.Unix(1422172800, 0)), 6350 TimeArgInQuery: aws.Time(time.Unix(1422172800, 0)), 6351 TimeCustom: aws.Time(time.Unix(1422172800, 0)), 6352 TimeCustomInHeader: aws.Time(time.Unix(1422172800, 0)), 6353 TimeCustomInQuery: aws.Time(time.Unix(1422172800, 0)), 6354 TimeFormat: aws.Time(time.Unix(1422172800, 0)), 6355 TimeFormatInHeader: aws.Time(time.Unix(1422172800, 0)), 6356 TimeFormatInQuery: aws.Time(time.Unix(1422172800, 0)), 6357 } 6358 req, _ := svc.InputService11TestCaseOperation1Request(input) 6359 r := req.HTTPRequest 6360 6361 // build request 6362 req.Build() 6363 if req.Error != nil { 6364 t.Errorf("expect no error, got %v", req.Error) 6365 } 6366 6367 // assert body 6368 if r.Body == nil { 6369 t.Errorf("expect body not to be nil") 6370 } 6371 body := util.SortXML(r.Body) 6372 awstesting.AssertXML(t, `<TimestampStructure xmlns="https://foo/"><TimeArg xmlns="https://foo/">2015-01-25T08:00:00Z</TimeArg><TimeCustom xmlns="https://foo/">Sun, 25 Jan 2015 08:00:00 GMT</TimeCustom><TimeFormat xmlns="https://foo/">Sun, 25 Jan 2015 08:00:00 GMT</TimeFormat></TimestampStructure>`, util.Trim(string(body)), InputService11TestShapeInputService11TestCaseOperation1Input{}) 6373 6374 // assert URL 6375 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone?TimeQuery=2015-01-25T08%3A00%3A00Z&TimeCustomQuery=1422172800&TimeFormatQuery=1422172800", r.URL.String()) 6376 6377 // assert headers 6378 if e, a := "Sun, 25 Jan 2015 08:00:00 GMT", r.Header.Get("x-amz-timearg"); e != a { 6379 t.Errorf("expect %v, got %v", e, a) 6380 } 6381 if e, a := "1422172800", r.Header.Get("x-amz-timecustom-header"); e != a { 6382 t.Errorf("expect %v, got %v", e, a) 6383 } 6384 if e, a := "1422172800", r.Header.Get("x-amz-timeformat-header"); e != a { 6385 t.Errorf("expect %v, got %v", e, a) 6386 } 6387 6388} 6389 6390func TestInputService12ProtocolTestHeaderMapsCase1(t *testing.T) { 6391 svc := NewInputService12ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6392 input := &InputService12TestShapeInputService12TestCaseOperation1Input{ 6393 Foo: map[string]*string{ 6394 "a": aws.String("b"), 6395 "c": aws.String("d"), 6396 }, 6397 } 6398 req, _ := svc.InputService12TestCaseOperation1Request(input) 6399 r := req.HTTPRequest 6400 6401 // build request 6402 req.Build() 6403 if req.Error != nil { 6404 t.Errorf("expect no error, got %v", req.Error) 6405 } 6406 6407 // assert URL 6408 awstesting.AssertURL(t, "https://test/", r.URL.String()) 6409 6410 // assert headers 6411 if e, a := "b", r.Header.Get("x-foo-a"); e != a { 6412 t.Errorf("expect %v, got %v", e, a) 6413 } 6414 if e, a := "d", r.Header.Get("x-foo-c"); e != a { 6415 t.Errorf("expect %v, got %v", e, a) 6416 } 6417 6418} 6419 6420func TestInputService13ProtocolTestQuerystringListOfStringsCase1(t *testing.T) { 6421 svc := NewInputService13ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6422 input := &InputService13TestShapeInputService13TestCaseOperation1Input{ 6423 Items: []*string{ 6424 aws.String("value1"), 6425 aws.String("value2"), 6426 }, 6427 } 6428 req, _ := svc.InputService13TestCaseOperation1Request(input) 6429 r := req.HTTPRequest 6430 6431 // build request 6432 req.Build() 6433 if req.Error != nil { 6434 t.Errorf("expect no error, got %v", req.Error) 6435 } 6436 6437 // assert URL 6438 awstesting.AssertURL(t, "https://test/path?item=value1&item=value2", r.URL.String()) 6439 6440 // assert headers 6441 6442} 6443 6444func TestInputService14ProtocolTestStringToStringMapsInQuerystringCase1(t *testing.T) { 6445 svc := NewInputService14ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6446 input := &InputService14TestShapeInputService14TestCaseOperation1Input{ 6447 PipelineId: aws.String("foo"), 6448 QueryDoc: map[string]*string{ 6449 "bar": aws.String("baz"), 6450 "fizz": aws.String("buzz"), 6451 }, 6452 } 6453 req, _ := svc.InputService14TestCaseOperation1Request(input) 6454 r := req.HTTPRequest 6455 6456 // build request 6457 req.Build() 6458 if req.Error != nil { 6459 t.Errorf("expect no error, got %v", req.Error) 6460 } 6461 6462 // assert URL 6463 awstesting.AssertURL(t, "https://test/2014-01-01/jobsByPipeline/foo?bar=baz&fizz=buzz", r.URL.String()) 6464 6465 // assert headers 6466 6467} 6468 6469func TestInputService15ProtocolTestStringToStringListMapsInQuerystringCase1(t *testing.T) { 6470 svc := NewInputService15ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6471 input := &InputService15TestShapeInputService15TestCaseOperation1Input{ 6472 PipelineId: aws.String("id"), 6473 QueryDoc: map[string][]*string{ 6474 "fizz": { 6475 aws.String("buzz"), 6476 aws.String("pop"), 6477 }, 6478 "foo": { 6479 aws.String("bar"), 6480 aws.String("baz"), 6481 }, 6482 }, 6483 } 6484 req, _ := svc.InputService15TestCaseOperation1Request(input) 6485 r := req.HTTPRequest 6486 6487 // build request 6488 req.Build() 6489 if req.Error != nil { 6490 t.Errorf("expect no error, got %v", req.Error) 6491 } 6492 6493 // assert URL 6494 awstesting.AssertURL(t, "https://test/2014-01-01/jobsByPipeline/id?foo=bar&foo=baz&fizz=buzz&fizz=pop", r.URL.String()) 6495 6496 // assert headers 6497 6498} 6499 6500func TestInputService16ProtocolTestBooleanInQuerystringCase1(t *testing.T) { 6501 svc := NewInputService16ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6502 input := &InputService16TestShapeInputService16TestCaseOperation1Input{ 6503 BoolQuery: aws.Bool(true), 6504 } 6505 req, _ := svc.InputService16TestCaseOperation1Request(input) 6506 r := req.HTTPRequest 6507 6508 // build request 6509 req.Build() 6510 if req.Error != nil { 6511 t.Errorf("expect no error, got %v", req.Error) 6512 } 6513 6514 // assert URL 6515 awstesting.AssertURL(t, "https://test/path?bool-query=true", r.URL.String()) 6516 6517 // assert headers 6518 6519} 6520 6521func TestInputService16ProtocolTestBooleanInQuerystringCase2(t *testing.T) { 6522 svc := NewInputService16ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6523 input := &InputService16TestShapeInputService16TestCaseOperation2Input{ 6524 BoolQuery: aws.Bool(false), 6525 } 6526 req, _ := svc.InputService16TestCaseOperation2Request(input) 6527 r := req.HTTPRequest 6528 6529 // build request 6530 req.Build() 6531 if req.Error != nil { 6532 t.Errorf("expect no error, got %v", req.Error) 6533 } 6534 6535 // assert URL 6536 awstesting.AssertURL(t, "https://test/path?bool-query=false", r.URL.String()) 6537 6538 // assert headers 6539 6540} 6541 6542func TestInputService17ProtocolTestStringPayloadCase1(t *testing.T) { 6543 svc := NewInputService17ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6544 input := &InputService17TestShapeInputService17TestCaseOperation1Input{ 6545 Foo: aws.String("bar"), 6546 } 6547 req, _ := svc.InputService17TestCaseOperation1Request(input) 6548 r := req.HTTPRequest 6549 6550 // build request 6551 req.Build() 6552 if req.Error != nil { 6553 t.Errorf("expect no error, got %v", req.Error) 6554 } 6555 6556 // assert body 6557 if r.Body == nil { 6558 t.Errorf("expect body not to be nil") 6559 } 6560 body := util.SortXML(r.Body) 6561 if e, a := "bar", util.Trim(string(body)); e != a { 6562 t.Errorf("expect %v, got %v", e, a) 6563 } 6564 6565 // assert URL 6566 awstesting.AssertURL(t, "https://test/", r.URL.String()) 6567 6568 // assert headers 6569 6570} 6571 6572func TestInputService18ProtocolTestBlobPayloadCase1(t *testing.T) { 6573 svc := NewInputService18ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6574 input := &InputService18TestShapeInputService18TestCaseOperation1Input{ 6575 Foo: []byte("bar"), 6576 } 6577 req, _ := svc.InputService18TestCaseOperation1Request(input) 6578 r := req.HTTPRequest 6579 6580 // build request 6581 req.Build() 6582 if req.Error != nil { 6583 t.Errorf("expect no error, got %v", req.Error) 6584 } 6585 6586 // assert body 6587 if r.Body == nil { 6588 t.Errorf("expect body not to be nil") 6589 } 6590 body := util.SortXML(r.Body) 6591 if e, a := "bar", util.Trim(string(body)); e != a { 6592 t.Errorf("expect %v, got %v", e, a) 6593 } 6594 6595 // assert URL 6596 awstesting.AssertURL(t, "https://test/", r.URL.String()) 6597 6598 // assert headers 6599 6600} 6601 6602func TestInputService18ProtocolTestBlobPayloadCase2(t *testing.T) { 6603 svc := NewInputService18ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6604 input := &InputService18TestShapeInputService18TestCaseOperation2Input{} 6605 req, _ := svc.InputService18TestCaseOperation2Request(input) 6606 r := req.HTTPRequest 6607 6608 // build request 6609 req.Build() 6610 if req.Error != nil { 6611 t.Errorf("expect no error, got %v", req.Error) 6612 } 6613 6614 // assert URL 6615 awstesting.AssertURL(t, "https://test/", r.URL.String()) 6616 6617 // assert headers 6618 6619} 6620 6621func TestInputService19ProtocolTestStructurePayloadCase1(t *testing.T) { 6622 svc := NewInputService19ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6623 input := &InputService19TestShapeInputService19TestCaseOperation1Input{ 6624 Foo: &InputService19TestShapeFooShape{ 6625 Baz: aws.String("bar"), 6626 }, 6627 } 6628 req, _ := svc.InputService19TestCaseOperation1Request(input) 6629 r := req.HTTPRequest 6630 6631 // build request 6632 req.Build() 6633 if req.Error != nil { 6634 t.Errorf("expect no error, got %v", req.Error) 6635 } 6636 6637 // assert body 6638 if r.Body == nil { 6639 t.Errorf("expect body not to be nil") 6640 } 6641 body := util.SortXML(r.Body) 6642 awstesting.AssertXML(t, `<foo><baz>bar</baz></foo>`, util.Trim(string(body)), InputService19TestShapeInputService19TestCaseOperation1Input{}) 6643 6644 // assert URL 6645 awstesting.AssertURL(t, "https://test/", r.URL.String()) 6646 6647 // assert headers 6648 6649} 6650 6651func TestInputService19ProtocolTestStructurePayloadCase2(t *testing.T) { 6652 svc := NewInputService19ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6653 input := &InputService19TestShapeInputService19TestCaseOperation2Input{} 6654 req, _ := svc.InputService19TestCaseOperation2Request(input) 6655 r := req.HTTPRequest 6656 6657 // build request 6658 req.Build() 6659 if req.Error != nil { 6660 t.Errorf("expect no error, got %v", req.Error) 6661 } 6662 6663 // assert URL 6664 awstesting.AssertURL(t, "https://test/", r.URL.String()) 6665 6666 // assert headers 6667 6668} 6669 6670func TestInputService19ProtocolTestStructurePayloadCase3(t *testing.T) { 6671 svc := NewInputService19ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6672 input := &InputService19TestShapeInputService19TestCaseOperation3Input{ 6673 Foo: &InputService19TestShapeFooShape{}, 6674 } 6675 req, _ := svc.InputService19TestCaseOperation3Request(input) 6676 r := req.HTTPRequest 6677 6678 // build request 6679 req.Build() 6680 if req.Error != nil { 6681 t.Errorf("expect no error, got %v", req.Error) 6682 } 6683 6684 // assert body 6685 if r.Body == nil { 6686 t.Errorf("expect body not to be nil") 6687 } 6688 body := util.SortXML(r.Body) 6689 awstesting.AssertXML(t, `<foo></foo>`, util.Trim(string(body)), InputService19TestShapeInputService19TestCaseOperation3Input{}) 6690 6691 // assert URL 6692 awstesting.AssertURL(t, "https://test/", r.URL.String()) 6693 6694 // assert headers 6695 6696} 6697 6698func TestInputService19ProtocolTestStructurePayloadCase4(t *testing.T) { 6699 svc := NewInputService19ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6700 input := &InputService19TestShapeInputService19TestCaseOperation4Input{} 6701 req, _ := svc.InputService19TestCaseOperation4Request(input) 6702 r := req.HTTPRequest 6703 6704 // build request 6705 req.Build() 6706 if req.Error != nil { 6707 t.Errorf("expect no error, got %v", req.Error) 6708 } 6709 6710 // assert URL 6711 awstesting.AssertURL(t, "https://test/", r.URL.String()) 6712 6713 // assert headers 6714 6715} 6716 6717func TestInputService20ProtocolTestXMLAttributeCase1(t *testing.T) { 6718 svc := NewInputService20ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6719 input := &InputService20TestShapeInputService20TestCaseOperation1Input{ 6720 Grant: &InputService20TestShapeGrant{ 6721 Grantee: &InputService20TestShapeGrantee{ 6722 EmailAddress: aws.String("foo@example.com"), 6723 Type: aws.String("CanonicalUser"), 6724 }, 6725 }, 6726 } 6727 req, _ := svc.InputService20TestCaseOperation1Request(input) 6728 r := req.HTTPRequest 6729 6730 // build request 6731 req.Build() 6732 if req.Error != nil { 6733 t.Errorf("expect no error, got %v", req.Error) 6734 } 6735 6736 // assert body 6737 if r.Body == nil { 6738 t.Errorf("expect body not to be nil") 6739 } 6740 body := util.SortXML(r.Body) 6741 awstesting.AssertXML(t, `<Grant xmlns:_xmlns="xmlns" _xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:XMLSchema-instance="http://www.w3.org/2001/XMLSchema-instance" XMLSchema-instance:type="CanonicalUser"><Grantee><EmailAddress>foo@example.com</EmailAddress></Grantee></Grant>`, util.Trim(string(body)), InputService20TestShapeInputService20TestCaseOperation1Input{}) 6742 6743 // assert URL 6744 awstesting.AssertURL(t, "https://test/", r.URL.String()) 6745 6746 // assert headers 6747 6748} 6749 6750func TestInputService21ProtocolTestGreedyKeysCase1(t *testing.T) { 6751 svc := NewInputService21ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6752 input := &InputService21TestShapeInputService21TestCaseOperation1Input{ 6753 Bucket: aws.String("my/bucket"), 6754 Key: aws.String("testing /123"), 6755 } 6756 req, _ := svc.InputService21TestCaseOperation1Request(input) 6757 r := req.HTTPRequest 6758 6759 // build request 6760 req.Build() 6761 if req.Error != nil { 6762 t.Errorf("expect no error, got %v", req.Error) 6763 } 6764 6765 // assert URL 6766 awstesting.AssertURL(t, "https://test/my%2Fbucket/testing%20/123", r.URL.String()) 6767 6768 // assert headers 6769 6770} 6771 6772func TestInputService22ProtocolTestOmitsNullQueryParamsButSerializesEmptyStringsCase1(t *testing.T) { 6773 svc := NewInputService22ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6774 input := &InputService22TestShapeInputService22TestCaseOperation1Input{} 6775 req, _ := svc.InputService22TestCaseOperation1Request(input) 6776 r := req.HTTPRequest 6777 6778 // build request 6779 req.Build() 6780 if req.Error != nil { 6781 t.Errorf("expect no error, got %v", req.Error) 6782 } 6783 6784 // assert URL 6785 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6786 6787 // assert headers 6788 6789} 6790 6791func TestInputService22ProtocolTestOmitsNullQueryParamsButSerializesEmptyStringsCase2(t *testing.T) { 6792 svc := NewInputService22ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6793 input := &InputService22TestShapeInputService22TestCaseOperation2Input{ 6794 Foo: aws.String(""), 6795 } 6796 req, _ := svc.InputService22TestCaseOperation2Request(input) 6797 r := req.HTTPRequest 6798 6799 // build request 6800 req.Build() 6801 if req.Error != nil { 6802 t.Errorf("expect no error, got %v", req.Error) 6803 } 6804 6805 // assert URL 6806 awstesting.AssertURL(t, "https://test/path?abc=mno¶m-name=", r.URL.String()) 6807 6808 // assert headers 6809 6810} 6811 6812func TestInputService23ProtocolTestRecursiveShapesCase1(t *testing.T) { 6813 svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6814 input := &InputService23TestShapeInputService23TestCaseOperation1Input{ 6815 RecursiveStruct: &InputService23TestShapeRecursiveStructType{ 6816 NoRecurse: aws.String("foo"), 6817 }, 6818 } 6819 req, _ := svc.InputService23TestCaseOperation1Request(input) 6820 r := req.HTTPRequest 6821 6822 // build request 6823 req.Build() 6824 if req.Error != nil { 6825 t.Errorf("expect no error, got %v", req.Error) 6826 } 6827 6828 // assert body 6829 if r.Body == nil { 6830 t.Errorf("expect body not to be nil") 6831 } 6832 body := util.SortXML(r.Body) 6833 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></RecursiveStruct></OperationRequest>`, util.Trim(string(body)), InputService23TestShapeInputService23TestCaseOperation1Input{}) 6834 6835 // assert URL 6836 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6837 6838 // assert headers 6839 6840} 6841 6842func TestInputService23ProtocolTestRecursiveShapesCase2(t *testing.T) { 6843 svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6844 input := &InputService23TestShapeInputService23TestCaseOperation2Input{ 6845 RecursiveStruct: &InputService23TestShapeRecursiveStructType{ 6846 RecursiveStruct: &InputService23TestShapeRecursiveStructType{ 6847 NoRecurse: aws.String("foo"), 6848 }, 6849 }, 6850 } 6851 req, _ := svc.InputService23TestCaseOperation2Request(input) 6852 r := req.HTTPRequest 6853 6854 // build request 6855 req.Build() 6856 if req.Error != nil { 6857 t.Errorf("expect no error, got %v", req.Error) 6858 } 6859 6860 // assert body 6861 if r.Body == nil { 6862 t.Errorf("expect body not to be nil") 6863 } 6864 body := util.SortXML(r.Body) 6865 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></RecursiveStruct></RecursiveStruct></OperationRequest>`, util.Trim(string(body)), InputService23TestShapeInputService23TestCaseOperation2Input{}) 6866 6867 // assert URL 6868 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6869 6870 // assert headers 6871 6872} 6873 6874func TestInputService23ProtocolTestRecursiveShapesCase3(t *testing.T) { 6875 svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6876 input := &InputService23TestShapeInputService23TestCaseOperation3Input{ 6877 RecursiveStruct: &InputService23TestShapeRecursiveStructType{ 6878 RecursiveStruct: &InputService23TestShapeRecursiveStructType{ 6879 RecursiveStruct: &InputService23TestShapeRecursiveStructType{ 6880 RecursiveStruct: &InputService23TestShapeRecursiveStructType{ 6881 NoRecurse: aws.String("foo"), 6882 }, 6883 }, 6884 }, 6885 }, 6886 } 6887 req, _ := svc.InputService23TestCaseOperation3Request(input) 6888 r := req.HTTPRequest 6889 6890 // build request 6891 req.Build() 6892 if req.Error != nil { 6893 t.Errorf("expect no error, got %v", req.Error) 6894 } 6895 6896 // assert body 6897 if r.Body == nil { 6898 t.Errorf("expect body not to be nil") 6899 } 6900 body := util.SortXML(r.Body) 6901 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></RecursiveStruct></RecursiveStruct></RecursiveStruct></RecursiveStruct></OperationRequest>`, util.Trim(string(body)), InputService23TestShapeInputService23TestCaseOperation3Input{}) 6902 6903 // assert URL 6904 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6905 6906 // assert headers 6907 6908} 6909 6910func TestInputService23ProtocolTestRecursiveShapesCase4(t *testing.T) { 6911 svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6912 input := &InputService23TestShapeInputService23TestCaseOperation4Input{ 6913 RecursiveStruct: &InputService23TestShapeRecursiveStructType{ 6914 RecursiveList: []*InputService23TestShapeRecursiveStructType{ 6915 { 6916 NoRecurse: aws.String("foo"), 6917 }, 6918 { 6919 NoRecurse: aws.String("bar"), 6920 }, 6921 }, 6922 }, 6923 } 6924 req, _ := svc.InputService23TestCaseOperation4Request(input) 6925 r := req.HTTPRequest 6926 6927 // build request 6928 req.Build() 6929 if req.Error != nil { 6930 t.Errorf("expect no error, got %v", req.Error) 6931 } 6932 6933 // assert body 6934 if r.Body == nil { 6935 t.Errorf("expect body not to be nil") 6936 } 6937 body := util.SortXML(r.Body) 6938 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveList xmlns="https://foo/"><member xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></member><member xmlns="https://foo/"><NoRecurse xmlns="https://foo/">bar</NoRecurse></member></RecursiveList></RecursiveStruct></OperationRequest>`, util.Trim(string(body)), InputService23TestShapeInputService23TestCaseOperation4Input{}) 6939 6940 // assert URL 6941 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6942 6943 // assert headers 6944 6945} 6946 6947func TestInputService23ProtocolTestRecursiveShapesCase5(t *testing.T) { 6948 svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6949 input := &InputService23TestShapeInputService23TestCaseOperation5Input{ 6950 RecursiveStruct: &InputService23TestShapeRecursiveStructType{ 6951 RecursiveList: []*InputService23TestShapeRecursiveStructType{ 6952 { 6953 NoRecurse: aws.String("foo"), 6954 }, 6955 { 6956 RecursiveStruct: &InputService23TestShapeRecursiveStructType{ 6957 NoRecurse: aws.String("bar"), 6958 }, 6959 }, 6960 }, 6961 }, 6962 } 6963 req, _ := svc.InputService23TestCaseOperation5Request(input) 6964 r := req.HTTPRequest 6965 6966 // build request 6967 req.Build() 6968 if req.Error != nil { 6969 t.Errorf("expect no error, got %v", req.Error) 6970 } 6971 6972 // assert body 6973 if r.Body == nil { 6974 t.Errorf("expect body not to be nil") 6975 } 6976 body := util.SortXML(r.Body) 6977 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveList xmlns="https://foo/"><member xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></member><member xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><NoRecurse xmlns="https://foo/">bar</NoRecurse></RecursiveStruct></member></RecursiveList></RecursiveStruct></OperationRequest>`, util.Trim(string(body)), InputService23TestShapeInputService23TestCaseOperation5Input{}) 6978 6979 // assert URL 6980 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6981 6982 // assert headers 6983 6984} 6985 6986func TestInputService23ProtocolTestRecursiveShapesCase6(t *testing.T) { 6987 svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 6988 input := &InputService23TestShapeInputService23TestCaseOperation6Input{ 6989 RecursiveStruct: &InputService23TestShapeRecursiveStructType{ 6990 RecursiveMap: map[string]*InputService23TestShapeRecursiveStructType{ 6991 "bar": { 6992 NoRecurse: aws.String("bar"), 6993 }, 6994 "foo": { 6995 NoRecurse: aws.String("foo"), 6996 }, 6997 }, 6998 }, 6999 } 7000 req, _ := svc.InputService23TestCaseOperation6Request(input) 7001 r := req.HTTPRequest 7002 7003 // build request 7004 req.Build() 7005 if req.Error != nil { 7006 t.Errorf("expect no error, got %v", req.Error) 7007 } 7008 7009 // assert body 7010 if r.Body == nil { 7011 t.Errorf("expect body not to be nil") 7012 } 7013 body := util.SortXML(r.Body) 7014 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><RecursiveMap xmlns="https://foo/"><entry xmlns="https://foo/"><key xmlns="https://foo/">foo</key><value xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></value></entry><entry xmlns="https://foo/"><key xmlns="https://foo/">bar</key><value xmlns="https://foo/"><NoRecurse xmlns="https://foo/">bar</NoRecurse></value></entry></RecursiveMap></RecursiveStruct></OperationRequest>`, util.Trim(string(body)), InputService23TestShapeInputService23TestCaseOperation6Input{}) 7015 7016 // assert URL 7017 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 7018 7019 // assert headers 7020 7021} 7022 7023func TestInputService24ProtocolTestIdempotencyTokenAutoFillCase1(t *testing.T) { 7024 svc := NewInputService24ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 7025 input := &InputService24TestShapeInputService24TestCaseOperation1Input{ 7026 Token: aws.String("abc123"), 7027 } 7028 req, _ := svc.InputService24TestCaseOperation1Request(input) 7029 r := req.HTTPRequest 7030 7031 // build request 7032 req.Build() 7033 if req.Error != nil { 7034 t.Errorf("expect no error, got %v", req.Error) 7035 } 7036 7037 // assert body 7038 if r.Body == nil { 7039 t.Errorf("expect body not to be nil") 7040 } 7041 body := util.SortXML(r.Body) 7042 awstesting.AssertXML(t, `<InputShape><Token>abc123</Token></InputShape>`, util.Trim(string(body)), InputService24TestShapeInputService24TestCaseOperation1Input{}) 7043 7044 // assert URL 7045 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 7046 7047 // assert headers 7048 7049} 7050 7051func TestInputService24ProtocolTestIdempotencyTokenAutoFillCase2(t *testing.T) { 7052 svc := NewInputService24ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 7053 input := &InputService24TestShapeInputService24TestCaseOperation2Input{} 7054 req, _ := svc.InputService24TestCaseOperation2Request(input) 7055 r := req.HTTPRequest 7056 7057 // build request 7058 req.Build() 7059 if req.Error != nil { 7060 t.Errorf("expect no error, got %v", req.Error) 7061 } 7062 7063 // assert body 7064 if r.Body == nil { 7065 t.Errorf("expect body not to be nil") 7066 } 7067 body := util.SortXML(r.Body) 7068 awstesting.AssertXML(t, `<InputShape><Token>00000000-0000-4000-8000-000000000000</Token></InputShape>`, util.Trim(string(body)), InputService24TestShapeInputService24TestCaseOperation2Input{}) 7069 7070 // assert URL 7071 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 7072 7073 // assert headers 7074 7075} 7076 7077func TestInputService25ProtocolTestEnumCase1(t *testing.T) { 7078 svc := NewInputService25ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 7079 input := &InputService25TestShapeInputService25TestCaseOperation1Input{ 7080 FooEnum: aws.String("foo"), 7081 HeaderEnum: aws.String("baz"), 7082 ListEnums: []*string{ 7083 aws.String("foo"), 7084 aws.String(""), 7085 aws.String("bar"), 7086 }, 7087 URIFooEnum: aws.String("bar"), 7088 URIListEnums: []*string{ 7089 aws.String("0"), 7090 aws.String(""), 7091 aws.String("1"), 7092 }, 7093 } 7094 req, _ := svc.InputService25TestCaseOperation1Request(input) 7095 r := req.HTTPRequest 7096 7097 // build request 7098 req.Build() 7099 if req.Error != nil { 7100 t.Errorf("expect no error, got %v", req.Error) 7101 } 7102 7103 // assert body 7104 if r.Body == nil { 7105 t.Errorf("expect body not to be nil") 7106 } 7107 body := util.SortXML(r.Body) 7108 awstesting.AssertXML(t, `<InputShape><FooEnum>foo</FooEnum><ListEnums><member>foo</member><member></member><member>bar</member></ListEnums></InputShape>`, util.Trim(string(body)), InputService25TestShapeInputService25TestCaseOperation1Input{}) 7109 7110 // assert URL 7111 awstesting.AssertURL(t, "https://test/Enum/bar?ListEnums=0&ListEnums=&ListEnums=1", r.URL.String()) 7112 7113 // assert headers 7114 if e, a := "baz", r.Header.Get("x-amz-enum"); e != a { 7115 t.Errorf("expect %v, got %v", e, a) 7116 } 7117 7118} 7119 7120func TestInputService25ProtocolTestEnumCase2(t *testing.T) { 7121 svc := NewInputService25ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 7122 input := &InputService25TestShapeInputService25TestCaseOperation2Input{ 7123 URIFooEnum: aws.String("bar"), 7124 } 7125 req, _ := svc.InputService25TestCaseOperation2Request(input) 7126 r := req.HTTPRequest 7127 7128 // build request 7129 req.Build() 7130 if req.Error != nil { 7131 t.Errorf("expect no error, got %v", req.Error) 7132 } 7133 7134 // assert URL 7135 awstesting.AssertURL(t, "https://test/Enum/bar", r.URL.String()) 7136 7137 // assert headers 7138 7139} 7140 7141func TestInputService26ProtocolTestEndpointHostTraitCase1(t *testing.T) { 7142 svc := NewInputService26ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://service.region.amazonaws.com")}) 7143 input := &InputService26TestShapeInputService26TestCaseOperation1Input{ 7144 Name: aws.String("myname"), 7145 } 7146 req, _ := svc.InputService26TestCaseOperation1Request(input) 7147 r := req.HTTPRequest 7148 7149 // build request 7150 req.Build() 7151 if req.Error != nil { 7152 t.Errorf("expect no error, got %v", req.Error) 7153 } 7154 7155 // assert body 7156 if r.Body == nil { 7157 t.Errorf("expect body not to be nil") 7158 } 7159 body := util.SortXML(r.Body) 7160 awstesting.AssertXML(t, `<StaticOpRequest><Name>myname</Name></StaticOpRequest>`, util.Trim(string(body)), InputService26TestShapeInputService26TestCaseOperation1Input{}) 7161 7162 // assert URL 7163 awstesting.AssertURL(t, "https://data-service.region.amazonaws.com/path", r.URL.String()) 7164 7165 // assert headers 7166 7167} 7168 7169func TestInputService26ProtocolTestEndpointHostTraitCase2(t *testing.T) { 7170 svc := NewInputService26ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://service.region.amazonaws.com")}) 7171 input := &InputService26TestShapeInputService26TestCaseOperation2Input{ 7172 Name: aws.String("myname"), 7173 } 7174 req, _ := svc.InputService26TestCaseOperation2Request(input) 7175 r := req.HTTPRequest 7176 7177 // build request 7178 req.Build() 7179 if req.Error != nil { 7180 t.Errorf("expect no error, got %v", req.Error) 7181 } 7182 7183 // assert body 7184 if r.Body == nil { 7185 t.Errorf("expect body not to be nil") 7186 } 7187 body := util.SortXML(r.Body) 7188 awstesting.AssertXML(t, `<MemberRefOpRequest><Name>myname</Name></MemberRefOpRequest>`, util.Trim(string(body)), InputService26TestShapeInputService26TestCaseOperation2Input{}) 7189 7190 // assert URL 7191 awstesting.AssertURL(t, "https://foo-myname.service.region.amazonaws.com/path", r.URL.String()) 7192 7193 // assert headers 7194 7195} 7196 7197func TestInputService27ProtocolTestHeaderWhitespaceCase1(t *testing.T) { 7198 svc := NewInputService27ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 7199 input := &InputService27TestShapeInputService27TestCaseOperation1Input{ 7200 Header1: aws.String(" headerValue"), 7201 HeaderMap: map[string]*string{ 7202 " key-leading-space": aws.String("value"), 7203 " key-with-space ": aws.String("value"), 7204 "leading-space": aws.String(" value"), 7205 "leading-tab": aws.String(" value"), 7206 "with-space": aws.String(" value "), 7207 }, 7208 } 7209 req, _ := svc.InputService27TestCaseOperation1Request(input) 7210 r := req.HTTPRequest 7211 7212 // build request 7213 req.Build() 7214 if req.Error != nil { 7215 t.Errorf("expect no error, got %v", req.Error) 7216 } 7217 7218 // assert URL 7219 awstesting.AssertURL(t, "https://test/", r.URL.String()) 7220 7221 // assert headers 7222 if e, a := "value", r.Header.Get("header-map-key-leading-space"); e != a { 7223 t.Errorf("expect %v, got %v", e, a) 7224 } 7225 if e, a := "value", r.Header.Get("header-map-key-with-space"); e != a { 7226 t.Errorf("expect %v, got %v", e, a) 7227 } 7228 if e, a := "value", r.Header.Get("header-map-leading-space"); e != a { 7229 t.Errorf("expect %v, got %v", e, a) 7230 } 7231 if e, a := "value", r.Header.Get("header-map-leading-tab"); e != a { 7232 t.Errorf("expect %v, got %v", e, a) 7233 } 7234 if e, a := "value", r.Header.Get("header-map-with-space"); e != a { 7235 t.Errorf("expect %v, got %v", e, a) 7236 } 7237 if e, a := "headerValue", r.Header.Get("header1"); e != a { 7238 t.Errorf("expect %v, got %v", e, a) 7239 } 7240 7241} 7242