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 SigningName: signingName, 80 SigningRegion: signingRegion, 81 Endpoint: endpoint, 82 APIVersion: "2014-01-01", 83 }, 84 handlers, 85 ), 86 } 87 88 // Handlers 89 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 90 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 91 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 92 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 93 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 94 95 return svc 96} 97 98// newRequest creates a new request for a InputService1ProtocolTest operation and runs any 99// custom request initialization. 100func (c *InputService1ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 101 req := c.NewRequest(op, params, data) 102 103 return req 104} 105 106const opInputService1TestCaseOperation1 = "OperationName" 107 108// InputService1TestCaseOperation1Request generates a "aws/request.Request" representing the 109// client's request for the InputService1TestCaseOperation1 operation. The "output" return 110// value will be populated with the request's response once the request complets 111// successfuly. 112// 113// Use "Send" method on the returned Request to send the API call to the service. 114// the "output" return value is not valid until after Send returns without error. 115// 116// See InputService1TestCaseOperation1 for more information on using the InputService1TestCaseOperation1 117// API call, and error handling. 118// 119// This method is useful when you want to inject custom logic or configuration 120// into the SDK's request lifecycle. Such as custom headers, or retry logic. 121// 122// 123// // Example sending a request using the InputService1TestCaseOperation1Request method. 124// req, resp := client.InputService1TestCaseOperation1Request(params) 125// 126// err := req.Send() 127// if err == nil { // resp is now filled 128// fmt.Println(resp) 129// } 130func (c *InputService1ProtocolTest) InputService1TestCaseOperation1Request(input *InputService1TestShapeInputService1TestCaseOperation2Input) (req *request.Request, output *InputService1TestShapeInputService1TestCaseOperation1Output) { 131 op := &request.Operation{ 132 Name: opInputService1TestCaseOperation1, 133 HTTPMethod: "POST", 134 HTTPPath: "/2014-01-01/hostedzone", 135 } 136 137 if input == nil { 138 input = &InputService1TestShapeInputService1TestCaseOperation2Input{} 139 } 140 141 output = &InputService1TestShapeInputService1TestCaseOperation1Output{} 142 req = c.newRequest(op, input, output) 143 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 144 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 145 return 146} 147 148// InputService1TestCaseOperation1 API operation for . 149// 150// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 151// with awserr.Error's Code and Message methods to get detailed information about 152// the error. 153// 154// See the AWS API reference guide for 's 155// API operation InputService1TestCaseOperation1 for usage and error information. 156func (c *InputService1ProtocolTest) InputService1TestCaseOperation1(input *InputService1TestShapeInputService1TestCaseOperation2Input) (*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 *InputService1TestShapeInputService1TestCaseOperation2Input, 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 complets 182// successfuly. 183// 184// Use "Send" method on the returned Request to send the API call to the service. 185// the "output" return value is not valid until after Send returns without error. 186// 187// See InputService1TestCaseOperation2 for more information on using the InputService1TestCaseOperation2 188// API call, and error handling. 189// 190// This method is useful when you want to inject custom logic or configuration 191// into the SDK's request lifecycle. Such as custom headers, or retry logic. 192// 193// 194// // Example sending a request using the InputService1TestCaseOperation2Request method. 195// req, resp := client.InputService1TestCaseOperation2Request(params) 196// 197// err := req.Send() 198// if err == nil { // resp is now filled 199// fmt.Println(resp) 200// } 201func (c *InputService1ProtocolTest) InputService1TestCaseOperation2Request(input *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.Remove(restxml.UnmarshalHandler) 215 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 216 return 217} 218 219// InputService1TestCaseOperation2 API operation for . 220// 221// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 222// with awserr.Error's Code and Message methods to get detailed information about 223// the error. 224// 225// See the AWS API reference guide for 's 226// API operation InputService1TestCaseOperation2 for usage and error information. 227func (c *InputService1ProtocolTest) InputService1TestCaseOperation2(input *InputService1TestShapeInputService1TestCaseOperation2Input) (*InputService1TestShapeInputService1TestCaseOperation2Output, error) { 228 req, out := c.InputService1TestCaseOperation2Request(input) 229 return out, req.Send() 230} 231 232// InputService1TestCaseOperation2WithContext is the same as InputService1TestCaseOperation2 with the addition of 233// the ability to pass a context and additional request options. 234// 235// See InputService1TestCaseOperation2 for details on how to use this API operation. 236// 237// The context must be non-nil and will be used for request cancellation. If 238// the context is nil a panic will occur. In the future the SDK may create 239// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 240// for more information on using Contexts. 241func (c *InputService1ProtocolTest) InputService1TestCaseOperation2WithContext(ctx aws.Context, input *InputService1TestShapeInputService1TestCaseOperation2Input, opts ...request.Option) (*InputService1TestShapeInputService1TestCaseOperation2Output, error) { 242 req, out := c.InputService1TestCaseOperation2Request(input) 243 req.SetContext(ctx) 244 req.ApplyOptions(opts...) 245 return out, req.Send() 246} 247 248const opInputService1TestCaseOperation3 = "OperationName" 249 250// InputService1TestCaseOperation3Request generates a "aws/request.Request" representing the 251// client's request for the InputService1TestCaseOperation3 operation. The "output" return 252// value will be populated with the request's response once the request complets 253// successfuly. 254// 255// Use "Send" method on the returned Request to send the API call to the service. 256// the "output" return value is not valid until after Send returns without error. 257// 258// See InputService1TestCaseOperation3 for more information on using the InputService1TestCaseOperation3 259// API call, and error handling. 260// 261// This method is useful when you want to inject custom logic or configuration 262// into the SDK's request lifecycle. Such as custom headers, or retry logic. 263// 264// 265// // Example sending a request using the InputService1TestCaseOperation3Request method. 266// req, resp := client.InputService1TestCaseOperation3Request(params) 267// 268// err := req.Send() 269// if err == nil { // resp is now filled 270// fmt.Println(resp) 271// } 272func (c *InputService1ProtocolTest) InputService1TestCaseOperation3Request(input *InputService1TestShapeInputService1TestCaseOperation3Input) (req *request.Request, output *InputService1TestShapeInputService1TestCaseOperation3Output) { 273 op := &request.Operation{ 274 Name: opInputService1TestCaseOperation3, 275 HTTPMethod: "GET", 276 HTTPPath: "/2014-01-01/hostedzone", 277 } 278 279 if input == nil { 280 input = &InputService1TestShapeInputService1TestCaseOperation3Input{} 281 } 282 283 output = &InputService1TestShapeInputService1TestCaseOperation3Output{} 284 req = c.newRequest(op, input, output) 285 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 286 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 287 return 288} 289 290// InputService1TestCaseOperation3 API operation for . 291// 292// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 293// with awserr.Error's Code and Message methods to get detailed information about 294// the error. 295// 296// See the AWS API reference guide for 's 297// API operation InputService1TestCaseOperation3 for usage and error information. 298func (c *InputService1ProtocolTest) InputService1TestCaseOperation3(input *InputService1TestShapeInputService1TestCaseOperation3Input) (*InputService1TestShapeInputService1TestCaseOperation3Output, error) { 299 req, out := c.InputService1TestCaseOperation3Request(input) 300 return out, req.Send() 301} 302 303// InputService1TestCaseOperation3WithContext is the same as InputService1TestCaseOperation3 with the addition of 304// the ability to pass a context and additional request options. 305// 306// See InputService1TestCaseOperation3 for details on how to use this API operation. 307// 308// The context must be non-nil and will be used for request cancellation. If 309// the context is nil a panic will occur. In the future the SDK may create 310// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 311// for more information on using Contexts. 312func (c *InputService1ProtocolTest) InputService1TestCaseOperation3WithContext(ctx aws.Context, input *InputService1TestShapeInputService1TestCaseOperation3Input, opts ...request.Option) (*InputService1TestShapeInputService1TestCaseOperation3Output, error) { 313 req, out := c.InputService1TestCaseOperation3Request(input) 314 req.SetContext(ctx) 315 req.ApplyOptions(opts...) 316 return out, req.Send() 317} 318 319type InputService1TestShapeInputService1TestCaseOperation1Output struct { 320 _ struct{} `type:"structure"` 321} 322 323type InputService1TestShapeInputService1TestCaseOperation2Input struct { 324 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 325 326 Description *string `type:"string"` 327 328 Name *string `type:"string"` 329} 330 331// SetDescription sets the Description field's value. 332func (s *InputService1TestShapeInputService1TestCaseOperation2Input) SetDescription(v string) *InputService1TestShapeInputService1TestCaseOperation2Input { 333 s.Description = &v 334 return s 335} 336 337// SetName sets the Name field's value. 338func (s *InputService1TestShapeInputService1TestCaseOperation2Input) SetName(v string) *InputService1TestShapeInputService1TestCaseOperation2Input { 339 s.Name = &v 340 return s 341} 342 343type InputService1TestShapeInputService1TestCaseOperation2Output struct { 344 _ struct{} `type:"structure"` 345} 346 347type InputService1TestShapeInputService1TestCaseOperation3Input struct { 348 _ struct{} `type:"structure"` 349} 350 351type InputService1TestShapeInputService1TestCaseOperation3Output struct { 352 _ struct{} `type:"structure"` 353} 354 355// InputService2ProtocolTest provides the API operation methods for making requests to 356// . See this package's package overview docs 357// for details on the service. 358// 359// InputService2ProtocolTest methods are safe to use concurrently. It is not safe to 360// modify mutate any of the struct's properties though. 361type InputService2ProtocolTest struct { 362 *client.Client 363} 364 365// New creates a new instance of the InputService2ProtocolTest client with a session. 366// If additional configuration is needed for the client instance use the optional 367// aws.Config parameter to add your extra config. 368// 369// Example: 370// // Create a InputService2ProtocolTest client from just a session. 371// svc := inputservice2protocoltest.New(mySession) 372// 373// // Create a InputService2ProtocolTest client with additional configuration 374// svc := inputservice2protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 375func NewInputService2ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService2ProtocolTest { 376 c := p.ClientConfig("inputservice2protocoltest", cfgs...) 377 return newInputService2ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 378} 379 380// newClient creates, initializes and returns a new service client instance. 381func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService2ProtocolTest { 382 svc := &InputService2ProtocolTest{ 383 Client: client.New( 384 cfg, 385 metadata.ClientInfo{ 386 ServiceName: "inputservice2protocoltest", 387 SigningName: signingName, 388 SigningRegion: signingRegion, 389 Endpoint: endpoint, 390 APIVersion: "2014-01-01", 391 }, 392 handlers, 393 ), 394 } 395 396 // Handlers 397 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 398 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 399 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 400 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 401 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 402 403 return svc 404} 405 406// newRequest creates a new request for a InputService2ProtocolTest operation and runs any 407// custom request initialization. 408func (c *InputService2ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 409 req := c.NewRequest(op, params, data) 410 411 return req 412} 413 414const opInputService2TestCaseOperation1 = "OperationName" 415 416// InputService2TestCaseOperation1Request generates a "aws/request.Request" representing the 417// client's request for the InputService2TestCaseOperation1 operation. The "output" return 418// value will be populated with the request's response once the request complets 419// successfuly. 420// 421// Use "Send" method on the returned Request to send the API call to the service. 422// the "output" return value is not valid until after Send returns without error. 423// 424// See InputService2TestCaseOperation1 for more information on using the InputService2TestCaseOperation1 425// API call, and error handling. 426// 427// This method is useful when you want to inject custom logic or configuration 428// into the SDK's request lifecycle. Such as custom headers, or retry logic. 429// 430// 431// // Example sending a request using the InputService2TestCaseOperation1Request method. 432// req, resp := client.InputService2TestCaseOperation1Request(params) 433// 434// err := req.Send() 435// if err == nil { // resp is now filled 436// fmt.Println(resp) 437// } 438func (c *InputService2ProtocolTest) InputService2TestCaseOperation1Request(input *InputService2TestShapeInputService2TestCaseOperation1Input) (req *request.Request, output *InputService2TestShapeInputService2TestCaseOperation1Output) { 439 op := &request.Operation{ 440 Name: opInputService2TestCaseOperation1, 441 HTTPMethod: "POST", 442 HTTPPath: "/2014-01-01/hostedzone", 443 } 444 445 if input == nil { 446 input = &InputService2TestShapeInputService2TestCaseOperation1Input{} 447 } 448 449 output = &InputService2TestShapeInputService2TestCaseOperation1Output{} 450 req = c.newRequest(op, input, output) 451 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 452 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 453 return 454} 455 456// InputService2TestCaseOperation1 API operation for . 457// 458// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 459// with awserr.Error's Code and Message methods to get detailed information about 460// the error. 461// 462// See the AWS API reference guide for 's 463// API operation InputService2TestCaseOperation1 for usage and error information. 464func (c *InputService2ProtocolTest) InputService2TestCaseOperation1(input *InputService2TestShapeInputService2TestCaseOperation1Input) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) { 465 req, out := c.InputService2TestCaseOperation1Request(input) 466 return out, req.Send() 467} 468 469// InputService2TestCaseOperation1WithContext is the same as InputService2TestCaseOperation1 with the addition of 470// the ability to pass a context and additional request options. 471// 472// See InputService2TestCaseOperation1 for details on how to use this API operation. 473// 474// The context must be non-nil and will be used for request cancellation. If 475// the context is nil a panic will occur. In the future the SDK may create 476// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 477// for more information on using Contexts. 478func (c *InputService2ProtocolTest) InputService2TestCaseOperation1WithContext(ctx aws.Context, input *InputService2TestShapeInputService2TestCaseOperation1Input, opts ...request.Option) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) { 479 req, out := c.InputService2TestCaseOperation1Request(input) 480 req.SetContext(ctx) 481 req.ApplyOptions(opts...) 482 return out, req.Send() 483} 484 485type InputService2TestShapeInputService2TestCaseOperation1Input struct { 486 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 487 488 First *bool `type:"boolean"` 489 490 Fourth *int64 `type:"integer"` 491 492 Second *bool `type:"boolean"` 493 494 Third *float64 `type:"float"` 495} 496 497// SetFirst sets the First field's value. 498func (s *InputService2TestShapeInputService2TestCaseOperation1Input) SetFirst(v bool) *InputService2TestShapeInputService2TestCaseOperation1Input { 499 s.First = &v 500 return s 501} 502 503// SetFourth sets the Fourth field's value. 504func (s *InputService2TestShapeInputService2TestCaseOperation1Input) SetFourth(v int64) *InputService2TestShapeInputService2TestCaseOperation1Input { 505 s.Fourth = &v 506 return s 507} 508 509// SetSecond sets the Second field's value. 510func (s *InputService2TestShapeInputService2TestCaseOperation1Input) SetSecond(v bool) *InputService2TestShapeInputService2TestCaseOperation1Input { 511 s.Second = &v 512 return s 513} 514 515// SetThird sets the Third field's value. 516func (s *InputService2TestShapeInputService2TestCaseOperation1Input) SetThird(v float64) *InputService2TestShapeInputService2TestCaseOperation1Input { 517 s.Third = &v 518 return s 519} 520 521type InputService2TestShapeInputService2TestCaseOperation1Output struct { 522 _ struct{} `type:"structure"` 523} 524 525// InputService3ProtocolTest provides the API operation methods for making requests to 526// . See this package's package overview docs 527// for details on the service. 528// 529// InputService3ProtocolTest methods are safe to use concurrently. It is not safe to 530// modify mutate any of the struct's properties though. 531type InputService3ProtocolTest struct { 532 *client.Client 533} 534 535// New creates a new instance of the InputService3ProtocolTest client with a session. 536// If additional configuration is needed for the client instance use the optional 537// aws.Config parameter to add your extra config. 538// 539// Example: 540// // Create a InputService3ProtocolTest client from just a session. 541// svc := inputservice3protocoltest.New(mySession) 542// 543// // Create a InputService3ProtocolTest client with additional configuration 544// svc := inputservice3protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 545func NewInputService3ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService3ProtocolTest { 546 c := p.ClientConfig("inputservice3protocoltest", cfgs...) 547 return newInputService3ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 548} 549 550// newClient creates, initializes and returns a new service client instance. 551func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService3ProtocolTest { 552 svc := &InputService3ProtocolTest{ 553 Client: client.New( 554 cfg, 555 metadata.ClientInfo{ 556 ServiceName: "inputservice3protocoltest", 557 SigningName: signingName, 558 SigningRegion: signingRegion, 559 Endpoint: endpoint, 560 APIVersion: "2014-01-01", 561 }, 562 handlers, 563 ), 564 } 565 566 // Handlers 567 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 568 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 569 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 570 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 571 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 572 573 return svc 574} 575 576// newRequest creates a new request for a InputService3ProtocolTest operation and runs any 577// custom request initialization. 578func (c *InputService3ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 579 req := c.NewRequest(op, params, data) 580 581 return req 582} 583 584const opInputService3TestCaseOperation1 = "OperationName" 585 586// InputService3TestCaseOperation1Request generates a "aws/request.Request" representing the 587// client's request for the InputService3TestCaseOperation1 operation. The "output" return 588// value will be populated with the request's response once the request complets 589// successfuly. 590// 591// Use "Send" method on the returned Request to send the API call to the service. 592// the "output" return value is not valid until after Send returns without error. 593// 594// See InputService3TestCaseOperation1 for more information on using the InputService3TestCaseOperation1 595// API call, and error handling. 596// 597// This method is useful when you want to inject custom logic or configuration 598// into the SDK's request lifecycle. Such as custom headers, or retry logic. 599// 600// 601// // Example sending a request using the InputService3TestCaseOperation1Request method. 602// req, resp := client.InputService3TestCaseOperation1Request(params) 603// 604// err := req.Send() 605// if err == nil { // resp is now filled 606// fmt.Println(resp) 607// } 608func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputService3TestCaseOperation2Input) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) { 609 op := &request.Operation{ 610 Name: opInputService3TestCaseOperation1, 611 HTTPMethod: "POST", 612 HTTPPath: "/2014-01-01/hostedzone", 613 } 614 615 if input == nil { 616 input = &InputService3TestShapeInputService3TestCaseOperation2Input{} 617 } 618 619 output = &InputService3TestShapeInputService3TestCaseOperation1Output{} 620 req = c.newRequest(op, input, output) 621 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 622 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 623 return 624} 625 626// InputService3TestCaseOperation1 API operation for . 627// 628// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 629// with awserr.Error's Code and Message methods to get detailed information about 630// the error. 631// 632// See the AWS API reference guide for 's 633// API operation InputService3TestCaseOperation1 for usage and error information. 634func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputService3TestCaseOperation2Input) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) { 635 req, out := c.InputService3TestCaseOperation1Request(input) 636 return out, req.Send() 637} 638 639// InputService3TestCaseOperation1WithContext is the same as InputService3TestCaseOperation1 with the addition of 640// the ability to pass a context and additional request options. 641// 642// See InputService3TestCaseOperation1 for details on how to use this API operation. 643// 644// The context must be non-nil and will be used for request cancellation. If 645// the context is nil a panic will occur. In the future the SDK may create 646// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 647// for more information on using Contexts. 648func (c *InputService3ProtocolTest) InputService3TestCaseOperation1WithContext(ctx aws.Context, input *InputService3TestShapeInputService3TestCaseOperation2Input, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) { 649 req, out := c.InputService3TestCaseOperation1Request(input) 650 req.SetContext(ctx) 651 req.ApplyOptions(opts...) 652 return out, req.Send() 653} 654 655const opInputService3TestCaseOperation2 = "OperationName" 656 657// InputService3TestCaseOperation2Request generates a "aws/request.Request" representing the 658// client's request for the InputService3TestCaseOperation2 operation. The "output" return 659// value will be populated with the request's response once the request complets 660// successfuly. 661// 662// Use "Send" method on the returned Request to send the API call to the service. 663// the "output" return value is not valid until after Send returns without error. 664// 665// See InputService3TestCaseOperation2 for more information on using the InputService3TestCaseOperation2 666// API call, and error handling. 667// 668// This method is useful when you want to inject custom logic or configuration 669// into the SDK's request lifecycle. Such as custom headers, or retry logic. 670// 671// 672// // Example sending a request using the InputService3TestCaseOperation2Request method. 673// req, resp := client.InputService3TestCaseOperation2Request(params) 674// 675// err := req.Send() 676// if err == nil { // resp is now filled 677// fmt.Println(resp) 678// } 679func (c *InputService3ProtocolTest) InputService3TestCaseOperation2Request(input *InputService3TestShapeInputService3TestCaseOperation2Input) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation2Output) { 680 op := &request.Operation{ 681 Name: opInputService3TestCaseOperation2, 682 HTTPMethod: "POST", 683 HTTPPath: "/2014-01-01/hostedzone", 684 } 685 686 if input == nil { 687 input = &InputService3TestShapeInputService3TestCaseOperation2Input{} 688 } 689 690 output = &InputService3TestShapeInputService3TestCaseOperation2Output{} 691 req = c.newRequest(op, input, output) 692 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 693 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 694 return 695} 696 697// InputService3TestCaseOperation2 API operation for . 698// 699// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 700// with awserr.Error's Code and Message methods to get detailed information about 701// the error. 702// 703// See the AWS API reference guide for 's 704// API operation InputService3TestCaseOperation2 for usage and error information. 705func (c *InputService3ProtocolTest) InputService3TestCaseOperation2(input *InputService3TestShapeInputService3TestCaseOperation2Input) (*InputService3TestShapeInputService3TestCaseOperation2Output, error) { 706 req, out := c.InputService3TestCaseOperation2Request(input) 707 return out, req.Send() 708} 709 710// InputService3TestCaseOperation2WithContext is the same as InputService3TestCaseOperation2 with the addition of 711// the ability to pass a context and additional request options. 712// 713// See InputService3TestCaseOperation2 for details on how to use this API operation. 714// 715// The context must be non-nil and will be used for request cancellation. If 716// the context is nil a panic will occur. In the future the SDK may create 717// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 718// for more information on using Contexts. 719func (c *InputService3ProtocolTest) InputService3TestCaseOperation2WithContext(ctx aws.Context, input *InputService3TestShapeInputService3TestCaseOperation2Input, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation2Output, error) { 720 req, out := c.InputService3TestCaseOperation2Request(input) 721 req.SetContext(ctx) 722 req.ApplyOptions(opts...) 723 return out, req.Send() 724} 725 726type InputService3TestShapeInputService3TestCaseOperation1Output struct { 727 _ struct{} `type:"structure"` 728} 729 730type InputService3TestShapeInputService3TestCaseOperation2Input struct { 731 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 732 733 Description *string `type:"string"` 734 735 SubStructure *InputService3TestShapeSubStructure `type:"structure"` 736} 737 738// SetDescription sets the Description field's value. 739func (s *InputService3TestShapeInputService3TestCaseOperation2Input) SetDescription(v string) *InputService3TestShapeInputService3TestCaseOperation2Input { 740 s.Description = &v 741 return s 742} 743 744// SetSubStructure sets the SubStructure field's value. 745func (s *InputService3TestShapeInputService3TestCaseOperation2Input) SetSubStructure(v *InputService3TestShapeSubStructure) *InputService3TestShapeInputService3TestCaseOperation2Input { 746 s.SubStructure = v 747 return s 748} 749 750type InputService3TestShapeInputService3TestCaseOperation2Output struct { 751 _ struct{} `type:"structure"` 752} 753 754type InputService3TestShapeSubStructure struct { 755 _ struct{} `type:"structure"` 756 757 Bar *string `type:"string"` 758 759 Foo *string `type:"string"` 760} 761 762// SetBar sets the Bar field's value. 763func (s *InputService3TestShapeSubStructure) SetBar(v string) *InputService3TestShapeSubStructure { 764 s.Bar = &v 765 return s 766} 767 768// SetFoo sets the Foo field's value. 769func (s *InputService3TestShapeSubStructure) SetFoo(v string) *InputService3TestShapeSubStructure { 770 s.Foo = &v 771 return s 772} 773 774// InputService4ProtocolTest provides the API operation methods for making requests to 775// . See this package's package overview docs 776// for details on the service. 777// 778// InputService4ProtocolTest methods are safe to use concurrently. It is not safe to 779// modify mutate any of the struct's properties though. 780type InputService4ProtocolTest struct { 781 *client.Client 782} 783 784// New creates a new instance of the InputService4ProtocolTest client with a session. 785// If additional configuration is needed for the client instance use the optional 786// aws.Config parameter to add your extra config. 787// 788// Example: 789// // Create a InputService4ProtocolTest client from just a session. 790// svc := inputservice4protocoltest.New(mySession) 791// 792// // Create a InputService4ProtocolTest client with additional configuration 793// svc := inputservice4protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 794func NewInputService4ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService4ProtocolTest { 795 c := p.ClientConfig("inputservice4protocoltest", cfgs...) 796 return newInputService4ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 797} 798 799// newClient creates, initializes and returns a new service client instance. 800func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService4ProtocolTest { 801 svc := &InputService4ProtocolTest{ 802 Client: client.New( 803 cfg, 804 metadata.ClientInfo{ 805 ServiceName: "inputservice4protocoltest", 806 SigningName: signingName, 807 SigningRegion: signingRegion, 808 Endpoint: endpoint, 809 APIVersion: "2014-01-01", 810 }, 811 handlers, 812 ), 813 } 814 815 // Handlers 816 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 817 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 818 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 819 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 820 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 821 822 return svc 823} 824 825// newRequest creates a new request for a InputService4ProtocolTest operation and runs any 826// custom request initialization. 827func (c *InputService4ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 828 req := c.NewRequest(op, params, data) 829 830 return req 831} 832 833const opInputService4TestCaseOperation1 = "OperationName" 834 835// InputService4TestCaseOperation1Request generates a "aws/request.Request" representing the 836// client's request for the InputService4TestCaseOperation1 operation. The "output" return 837// value will be populated with the request's response once the request complets 838// successfuly. 839// 840// Use "Send" method on the returned Request to send the API call to the service. 841// the "output" return value is not valid until after Send returns without error. 842// 843// See InputService4TestCaseOperation1 for more information on using the InputService4TestCaseOperation1 844// API call, and error handling. 845// 846// This method is useful when you want to inject custom logic or configuration 847// into the SDK's request lifecycle. Such as custom headers, or retry logic. 848// 849// 850// // Example sending a request using the InputService4TestCaseOperation1Request method. 851// req, resp := client.InputService4TestCaseOperation1Request(params) 852// 853// err := req.Send() 854// if err == nil { // resp is now filled 855// fmt.Println(resp) 856// } 857func (c *InputService4ProtocolTest) InputService4TestCaseOperation1Request(input *InputService4TestShapeInputService4TestCaseOperation1Input) (req *request.Request, output *InputService4TestShapeInputService4TestCaseOperation1Output) { 858 op := &request.Operation{ 859 Name: opInputService4TestCaseOperation1, 860 HTTPMethod: "POST", 861 HTTPPath: "/2014-01-01/hostedzone", 862 } 863 864 if input == nil { 865 input = &InputService4TestShapeInputService4TestCaseOperation1Input{} 866 } 867 868 output = &InputService4TestShapeInputService4TestCaseOperation1Output{} 869 req = c.newRequest(op, input, output) 870 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 871 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 872 return 873} 874 875// InputService4TestCaseOperation1 API operation for . 876// 877// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 878// with awserr.Error's Code and Message methods to get detailed information about 879// the error. 880// 881// See the AWS API reference guide for 's 882// API operation InputService4TestCaseOperation1 for usage and error information. 883func (c *InputService4ProtocolTest) InputService4TestCaseOperation1(input *InputService4TestShapeInputService4TestCaseOperation1Input) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) { 884 req, out := c.InputService4TestCaseOperation1Request(input) 885 return out, req.Send() 886} 887 888// InputService4TestCaseOperation1WithContext is the same as InputService4TestCaseOperation1 with the addition of 889// the ability to pass a context and additional request options. 890// 891// See InputService4TestCaseOperation1 for details on how to use this API operation. 892// 893// The context must be non-nil and will be used for request cancellation. If 894// the context is nil a panic will occur. In the future the SDK may create 895// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 896// for more information on using Contexts. 897func (c *InputService4ProtocolTest) InputService4TestCaseOperation1WithContext(ctx aws.Context, input *InputService4TestShapeInputService4TestCaseOperation1Input, opts ...request.Option) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) { 898 req, out := c.InputService4TestCaseOperation1Request(input) 899 req.SetContext(ctx) 900 req.ApplyOptions(opts...) 901 return out, req.Send() 902} 903 904type InputService4TestShapeInputService4TestCaseOperation1Input struct { 905 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 906 907 Description *string `type:"string"` 908 909 SubStructure *InputService4TestShapeSubStructure `type:"structure"` 910} 911 912// SetDescription sets the Description field's value. 913func (s *InputService4TestShapeInputService4TestCaseOperation1Input) SetDescription(v string) *InputService4TestShapeInputService4TestCaseOperation1Input { 914 s.Description = &v 915 return s 916} 917 918// SetSubStructure sets the SubStructure field's value. 919func (s *InputService4TestShapeInputService4TestCaseOperation1Input) SetSubStructure(v *InputService4TestShapeSubStructure) *InputService4TestShapeInputService4TestCaseOperation1Input { 920 s.SubStructure = v 921 return s 922} 923 924type InputService4TestShapeInputService4TestCaseOperation1Output struct { 925 _ struct{} `type:"structure"` 926} 927 928type InputService4TestShapeSubStructure struct { 929 _ struct{} `type:"structure"` 930 931 Bar *string `type:"string"` 932 933 Foo *string `type:"string"` 934} 935 936// SetBar sets the Bar field's value. 937func (s *InputService4TestShapeSubStructure) SetBar(v string) *InputService4TestShapeSubStructure { 938 s.Bar = &v 939 return s 940} 941 942// SetFoo sets the Foo field's value. 943func (s *InputService4TestShapeSubStructure) SetFoo(v string) *InputService4TestShapeSubStructure { 944 s.Foo = &v 945 return s 946} 947 948// InputService5ProtocolTest provides the API operation methods for making requests to 949// . See this package's package overview docs 950// for details on the service. 951// 952// InputService5ProtocolTest methods are safe to use concurrently. It is not safe to 953// modify mutate any of the struct's properties though. 954type InputService5ProtocolTest struct { 955 *client.Client 956} 957 958// New creates a new instance of the InputService5ProtocolTest client with a session. 959// If additional configuration is needed for the client instance use the optional 960// aws.Config parameter to add your extra config. 961// 962// Example: 963// // Create a InputService5ProtocolTest client from just a session. 964// svc := inputservice5protocoltest.New(mySession) 965// 966// // Create a InputService5ProtocolTest client with additional configuration 967// svc := inputservice5protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 968func NewInputService5ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService5ProtocolTest { 969 c := p.ClientConfig("inputservice5protocoltest", cfgs...) 970 return newInputService5ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 971} 972 973// newClient creates, initializes and returns a new service client instance. 974func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService5ProtocolTest { 975 svc := &InputService5ProtocolTest{ 976 Client: client.New( 977 cfg, 978 metadata.ClientInfo{ 979 ServiceName: "inputservice5protocoltest", 980 SigningName: signingName, 981 SigningRegion: signingRegion, 982 Endpoint: endpoint, 983 APIVersion: "2014-01-01", 984 }, 985 handlers, 986 ), 987 } 988 989 // Handlers 990 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 991 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 992 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 993 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 994 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 995 996 return svc 997} 998 999// newRequest creates a new request for a InputService5ProtocolTest operation and runs any 1000// custom request initialization. 1001func (c *InputService5ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1002 req := c.NewRequest(op, params, data) 1003 1004 return req 1005} 1006 1007const opInputService5TestCaseOperation1 = "OperationName" 1008 1009// InputService5TestCaseOperation1Request generates a "aws/request.Request" representing the 1010// client's request for the InputService5TestCaseOperation1 operation. The "output" return 1011// value will be populated with the request's response once the request complets 1012// successfuly. 1013// 1014// Use "Send" method on the returned Request to send the API call to the service. 1015// the "output" return value is not valid until after Send returns without error. 1016// 1017// See InputService5TestCaseOperation1 for more information on using the InputService5TestCaseOperation1 1018// API call, and error handling. 1019// 1020// This method is useful when you want to inject custom logic or configuration 1021// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1022// 1023// 1024// // Example sending a request using the InputService5TestCaseOperation1Request method. 1025// req, resp := client.InputService5TestCaseOperation1Request(params) 1026// 1027// err := req.Send() 1028// if err == nil { // resp is now filled 1029// fmt.Println(resp) 1030// } 1031func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputService5TestCaseOperation1Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) { 1032 op := &request.Operation{ 1033 Name: opInputService5TestCaseOperation1, 1034 HTTPMethod: "POST", 1035 HTTPPath: "/2014-01-01/hostedzone", 1036 } 1037 1038 if input == nil { 1039 input = &InputService5TestShapeInputService5TestCaseOperation1Input{} 1040 } 1041 1042 output = &InputService5TestShapeInputService5TestCaseOperation1Output{} 1043 req = c.newRequest(op, input, output) 1044 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 1045 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1046 return 1047} 1048 1049// InputService5TestCaseOperation1 API operation for . 1050// 1051// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1052// with awserr.Error's Code and Message methods to get detailed information about 1053// the error. 1054// 1055// See the AWS API reference guide for 's 1056// API operation InputService5TestCaseOperation1 for usage and error information. 1057func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputService5TestCaseOperation1Input) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) { 1058 req, out := c.InputService5TestCaseOperation1Request(input) 1059 return out, req.Send() 1060} 1061 1062// InputService5TestCaseOperation1WithContext is the same as InputService5TestCaseOperation1 with the addition of 1063// the ability to pass a context and additional request options. 1064// 1065// See InputService5TestCaseOperation1 for details on how to use this API operation. 1066// 1067// The context must be non-nil and will be used for request cancellation. If 1068// the context is nil a panic will occur. In the future the SDK may create 1069// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1070// for more information on using Contexts. 1071func (c *InputService5ProtocolTest) InputService5TestCaseOperation1WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation1Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) { 1072 req, out := c.InputService5TestCaseOperation1Request(input) 1073 req.SetContext(ctx) 1074 req.ApplyOptions(opts...) 1075 return out, req.Send() 1076} 1077 1078type InputService5TestShapeInputService5TestCaseOperation1Input struct { 1079 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 1080 1081 ListParam []*string `type:"list"` 1082} 1083 1084// SetListParam sets the ListParam field's value. 1085func (s *InputService5TestShapeInputService5TestCaseOperation1Input) SetListParam(v []*string) *InputService5TestShapeInputService5TestCaseOperation1Input { 1086 s.ListParam = v 1087 return s 1088} 1089 1090type InputService5TestShapeInputService5TestCaseOperation1Output struct { 1091 _ struct{} `type:"structure"` 1092} 1093 1094// InputService6ProtocolTest provides the API operation methods for making requests to 1095// . See this package's package overview docs 1096// for details on the service. 1097// 1098// InputService6ProtocolTest methods are safe to use concurrently. It is not safe to 1099// modify mutate any of the struct's properties though. 1100type InputService6ProtocolTest struct { 1101 *client.Client 1102} 1103 1104// New creates a new instance of the InputService6ProtocolTest client with a session. 1105// If additional configuration is needed for the client instance use the optional 1106// aws.Config parameter to add your extra config. 1107// 1108// Example: 1109// // Create a InputService6ProtocolTest client from just a session. 1110// svc := inputservice6protocoltest.New(mySession) 1111// 1112// // Create a InputService6ProtocolTest client with additional configuration 1113// svc := inputservice6protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1114func NewInputService6ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService6ProtocolTest { 1115 c := p.ClientConfig("inputservice6protocoltest", cfgs...) 1116 return newInputService6ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1117} 1118 1119// newClient creates, initializes and returns a new service client instance. 1120func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService6ProtocolTest { 1121 svc := &InputService6ProtocolTest{ 1122 Client: client.New( 1123 cfg, 1124 metadata.ClientInfo{ 1125 ServiceName: "inputservice6protocoltest", 1126 SigningName: signingName, 1127 SigningRegion: signingRegion, 1128 Endpoint: endpoint, 1129 APIVersion: "2014-01-01", 1130 }, 1131 handlers, 1132 ), 1133 } 1134 1135 // Handlers 1136 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1137 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1138 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1139 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1140 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1141 1142 return svc 1143} 1144 1145// newRequest creates a new request for a InputService6ProtocolTest operation and runs any 1146// custom request initialization. 1147func (c *InputService6ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1148 req := c.NewRequest(op, params, data) 1149 1150 return req 1151} 1152 1153const opInputService6TestCaseOperation1 = "OperationName" 1154 1155// InputService6TestCaseOperation1Request generates a "aws/request.Request" representing the 1156// client's request for the InputService6TestCaseOperation1 operation. The "output" return 1157// value will be populated with the request's response once the request complets 1158// successfuly. 1159// 1160// Use "Send" method on the returned Request to send the API call to the service. 1161// the "output" return value is not valid until after Send returns without error. 1162// 1163// See InputService6TestCaseOperation1 for more information on using the InputService6TestCaseOperation1 1164// API call, and error handling. 1165// 1166// This method is useful when you want to inject custom logic or configuration 1167// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1168// 1169// 1170// // Example sending a request using the InputService6TestCaseOperation1Request method. 1171// req, resp := client.InputService6TestCaseOperation1Request(params) 1172// 1173// err := req.Send() 1174// if err == nil { // resp is now filled 1175// fmt.Println(resp) 1176// } 1177func (c *InputService6ProtocolTest) InputService6TestCaseOperation1Request(input *InputService6TestShapeInputService6TestCaseOperation1Input) (req *request.Request, output *InputService6TestShapeInputService6TestCaseOperation1Output) { 1178 op := &request.Operation{ 1179 Name: opInputService6TestCaseOperation1, 1180 HTTPMethod: "POST", 1181 HTTPPath: "/2014-01-01/hostedzone", 1182 } 1183 1184 if input == nil { 1185 input = &InputService6TestShapeInputService6TestCaseOperation1Input{} 1186 } 1187 1188 output = &InputService6TestShapeInputService6TestCaseOperation1Output{} 1189 req = c.newRequest(op, input, output) 1190 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 1191 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1192 return 1193} 1194 1195// InputService6TestCaseOperation1 API operation for . 1196// 1197// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1198// with awserr.Error's Code and Message methods to get detailed information about 1199// the error. 1200// 1201// See the AWS API reference guide for 's 1202// API operation InputService6TestCaseOperation1 for usage and error information. 1203func (c *InputService6ProtocolTest) InputService6TestCaseOperation1(input *InputService6TestShapeInputService6TestCaseOperation1Input) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) { 1204 req, out := c.InputService6TestCaseOperation1Request(input) 1205 return out, req.Send() 1206} 1207 1208// InputService6TestCaseOperation1WithContext is the same as InputService6TestCaseOperation1 with the addition of 1209// the ability to pass a context and additional request options. 1210// 1211// See InputService6TestCaseOperation1 for details on how to use this API operation. 1212// 1213// The context must be non-nil and will be used for request cancellation. If 1214// the context is nil a panic will occur. In the future the SDK may create 1215// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1216// for more information on using Contexts. 1217func (c *InputService6ProtocolTest) InputService6TestCaseOperation1WithContext(ctx aws.Context, input *InputService6TestShapeInputService6TestCaseOperation1Input, opts ...request.Option) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) { 1218 req, out := c.InputService6TestCaseOperation1Request(input) 1219 req.SetContext(ctx) 1220 req.ApplyOptions(opts...) 1221 return out, req.Send() 1222} 1223 1224type InputService6TestShapeInputService6TestCaseOperation1Input struct { 1225 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 1226 1227 ListParam []*string `locationName:"AlternateName" locationNameList:"NotMember" type:"list"` 1228} 1229 1230// SetListParam sets the ListParam field's value. 1231func (s *InputService6TestShapeInputService6TestCaseOperation1Input) SetListParam(v []*string) *InputService6TestShapeInputService6TestCaseOperation1Input { 1232 s.ListParam = v 1233 return s 1234} 1235 1236type InputService6TestShapeInputService6TestCaseOperation1Output struct { 1237 _ struct{} `type:"structure"` 1238} 1239 1240// InputService7ProtocolTest provides the API operation methods for making requests to 1241// . See this package's package overview docs 1242// for details on the service. 1243// 1244// InputService7ProtocolTest methods are safe to use concurrently. It is not safe to 1245// modify mutate any of the struct's properties though. 1246type InputService7ProtocolTest struct { 1247 *client.Client 1248} 1249 1250// New creates a new instance of the InputService7ProtocolTest client with a session. 1251// If additional configuration is needed for the client instance use the optional 1252// aws.Config parameter to add your extra config. 1253// 1254// Example: 1255// // Create a InputService7ProtocolTest client from just a session. 1256// svc := inputservice7protocoltest.New(mySession) 1257// 1258// // Create a InputService7ProtocolTest client with additional configuration 1259// svc := inputservice7protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1260func NewInputService7ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService7ProtocolTest { 1261 c := p.ClientConfig("inputservice7protocoltest", cfgs...) 1262 return newInputService7ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1263} 1264 1265// newClient creates, initializes and returns a new service client instance. 1266func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService7ProtocolTest { 1267 svc := &InputService7ProtocolTest{ 1268 Client: client.New( 1269 cfg, 1270 metadata.ClientInfo{ 1271 ServiceName: "inputservice7protocoltest", 1272 SigningName: signingName, 1273 SigningRegion: signingRegion, 1274 Endpoint: endpoint, 1275 APIVersion: "2014-01-01", 1276 }, 1277 handlers, 1278 ), 1279 } 1280 1281 // Handlers 1282 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1283 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1284 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1285 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1286 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1287 1288 return svc 1289} 1290 1291// newRequest creates a new request for a InputService7ProtocolTest operation and runs any 1292// custom request initialization. 1293func (c *InputService7ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1294 req := c.NewRequest(op, params, data) 1295 1296 return req 1297} 1298 1299const opInputService7TestCaseOperation1 = "OperationName" 1300 1301// InputService7TestCaseOperation1Request generates a "aws/request.Request" representing the 1302// client's request for the InputService7TestCaseOperation1 operation. The "output" return 1303// value will be populated with the request's response once the request complets 1304// successfuly. 1305// 1306// Use "Send" method on the returned Request to send the API call to the service. 1307// the "output" return value is not valid until after Send returns without error. 1308// 1309// See InputService7TestCaseOperation1 for more information on using the InputService7TestCaseOperation1 1310// API call, and error handling. 1311// 1312// This method is useful when you want to inject custom logic or configuration 1313// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1314// 1315// 1316// // Example sending a request using the InputService7TestCaseOperation1Request method. 1317// req, resp := client.InputService7TestCaseOperation1Request(params) 1318// 1319// err := req.Send() 1320// if err == nil { // resp is now filled 1321// fmt.Println(resp) 1322// } 1323func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputService7TestCaseOperation1Input) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) { 1324 op := &request.Operation{ 1325 Name: opInputService7TestCaseOperation1, 1326 HTTPMethod: "POST", 1327 HTTPPath: "/2014-01-01/hostedzone", 1328 } 1329 1330 if input == nil { 1331 input = &InputService7TestShapeInputService7TestCaseOperation1Input{} 1332 } 1333 1334 output = &InputService7TestShapeInputService7TestCaseOperation1Output{} 1335 req = c.newRequest(op, input, output) 1336 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 1337 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1338 return 1339} 1340 1341// InputService7TestCaseOperation1 API operation for . 1342// 1343// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1344// with awserr.Error's Code and Message methods to get detailed information about 1345// the error. 1346// 1347// See the AWS API reference guide for 's 1348// API operation InputService7TestCaseOperation1 for usage and error information. 1349func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputService7TestCaseOperation1Input) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) { 1350 req, out := c.InputService7TestCaseOperation1Request(input) 1351 return out, req.Send() 1352} 1353 1354// InputService7TestCaseOperation1WithContext is the same as InputService7TestCaseOperation1 with the addition of 1355// the ability to pass a context and additional request options. 1356// 1357// See InputService7TestCaseOperation1 for details on how to use this API operation. 1358// 1359// The context must be non-nil and will be used for request cancellation. If 1360// the context is nil a panic will occur. In the future the SDK may create 1361// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1362// for more information on using Contexts. 1363func (c *InputService7ProtocolTest) InputService7TestCaseOperation1WithContext(ctx aws.Context, input *InputService7TestShapeInputService7TestCaseOperation1Input, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) { 1364 req, out := c.InputService7TestCaseOperation1Request(input) 1365 req.SetContext(ctx) 1366 req.ApplyOptions(opts...) 1367 return out, req.Send() 1368} 1369 1370type InputService7TestShapeInputService7TestCaseOperation1Input struct { 1371 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 1372 1373 ListParam []*string `type:"list" flattened:"true"` 1374} 1375 1376// SetListParam sets the ListParam field's value. 1377func (s *InputService7TestShapeInputService7TestCaseOperation1Input) SetListParam(v []*string) *InputService7TestShapeInputService7TestCaseOperation1Input { 1378 s.ListParam = v 1379 return s 1380} 1381 1382type InputService7TestShapeInputService7TestCaseOperation1Output struct { 1383 _ struct{} `type:"structure"` 1384} 1385 1386// InputService8ProtocolTest provides the API operation methods for making requests to 1387// . See this package's package overview docs 1388// for details on the service. 1389// 1390// InputService8ProtocolTest methods are safe to use concurrently. It is not safe to 1391// modify mutate any of the struct's properties though. 1392type InputService8ProtocolTest struct { 1393 *client.Client 1394} 1395 1396// New creates a new instance of the InputService8ProtocolTest client with a session. 1397// If additional configuration is needed for the client instance use the optional 1398// aws.Config parameter to add your extra config. 1399// 1400// Example: 1401// // Create a InputService8ProtocolTest client from just a session. 1402// svc := inputservice8protocoltest.New(mySession) 1403// 1404// // Create a InputService8ProtocolTest client with additional configuration 1405// svc := inputservice8protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1406func NewInputService8ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService8ProtocolTest { 1407 c := p.ClientConfig("inputservice8protocoltest", cfgs...) 1408 return newInputService8ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1409} 1410 1411// newClient creates, initializes and returns a new service client instance. 1412func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService8ProtocolTest { 1413 svc := &InputService8ProtocolTest{ 1414 Client: client.New( 1415 cfg, 1416 metadata.ClientInfo{ 1417 ServiceName: "inputservice8protocoltest", 1418 SigningName: signingName, 1419 SigningRegion: signingRegion, 1420 Endpoint: endpoint, 1421 APIVersion: "2014-01-01", 1422 }, 1423 handlers, 1424 ), 1425 } 1426 1427 // Handlers 1428 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1429 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1430 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1431 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1432 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1433 1434 return svc 1435} 1436 1437// newRequest creates a new request for a InputService8ProtocolTest operation and runs any 1438// custom request initialization. 1439func (c *InputService8ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1440 req := c.NewRequest(op, params, data) 1441 1442 return req 1443} 1444 1445const opInputService8TestCaseOperation1 = "OperationName" 1446 1447// InputService8TestCaseOperation1Request generates a "aws/request.Request" representing the 1448// client's request for the InputService8TestCaseOperation1 operation. The "output" return 1449// value will be populated with the request's response once the request complets 1450// successfuly. 1451// 1452// Use "Send" method on the returned Request to send the API call to the service. 1453// the "output" return value is not valid until after Send returns without error. 1454// 1455// See InputService8TestCaseOperation1 for more information on using the InputService8TestCaseOperation1 1456// API call, and error handling. 1457// 1458// This method is useful when you want to inject custom logic or configuration 1459// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1460// 1461// 1462// // Example sending a request using the InputService8TestCaseOperation1Request method. 1463// req, resp := client.InputService8TestCaseOperation1Request(params) 1464// 1465// err := req.Send() 1466// if err == nil { // resp is now filled 1467// fmt.Println(resp) 1468// } 1469func (c *InputService8ProtocolTest) InputService8TestCaseOperation1Request(input *InputService8TestShapeInputService8TestCaseOperation1Input) (req *request.Request, output *InputService8TestShapeInputService8TestCaseOperation1Output) { 1470 op := &request.Operation{ 1471 Name: opInputService8TestCaseOperation1, 1472 HTTPMethod: "POST", 1473 HTTPPath: "/2014-01-01/hostedzone", 1474 } 1475 1476 if input == nil { 1477 input = &InputService8TestShapeInputService8TestCaseOperation1Input{} 1478 } 1479 1480 output = &InputService8TestShapeInputService8TestCaseOperation1Output{} 1481 req = c.newRequest(op, input, output) 1482 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 1483 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1484 return 1485} 1486 1487// InputService8TestCaseOperation1 API operation for . 1488// 1489// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1490// with awserr.Error's Code and Message methods to get detailed information about 1491// the error. 1492// 1493// See the AWS API reference guide for 's 1494// API operation InputService8TestCaseOperation1 for usage and error information. 1495func (c *InputService8ProtocolTest) InputService8TestCaseOperation1(input *InputService8TestShapeInputService8TestCaseOperation1Input) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) { 1496 req, out := c.InputService8TestCaseOperation1Request(input) 1497 return out, req.Send() 1498} 1499 1500// InputService8TestCaseOperation1WithContext is the same as InputService8TestCaseOperation1 with the addition of 1501// the ability to pass a context and additional request options. 1502// 1503// See InputService8TestCaseOperation1 for details on how to use this API operation. 1504// 1505// The context must be non-nil and will be used for request cancellation. If 1506// the context is nil a panic will occur. In the future the SDK may create 1507// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1508// for more information on using Contexts. 1509func (c *InputService8ProtocolTest) InputService8TestCaseOperation1WithContext(ctx aws.Context, input *InputService8TestShapeInputService8TestCaseOperation1Input, opts ...request.Option) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) { 1510 req, out := c.InputService8TestCaseOperation1Request(input) 1511 req.SetContext(ctx) 1512 req.ApplyOptions(opts...) 1513 return out, req.Send() 1514} 1515 1516type InputService8TestShapeInputService8TestCaseOperation1Input struct { 1517 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 1518 1519 ListParam []*string `locationName:"item" type:"list" flattened:"true"` 1520} 1521 1522// SetListParam sets the ListParam field's value. 1523func (s *InputService8TestShapeInputService8TestCaseOperation1Input) SetListParam(v []*string) *InputService8TestShapeInputService8TestCaseOperation1Input { 1524 s.ListParam = v 1525 return s 1526} 1527 1528type InputService8TestShapeInputService8TestCaseOperation1Output struct { 1529 _ struct{} `type:"structure"` 1530} 1531 1532// InputService9ProtocolTest provides the API operation methods for making requests to 1533// . See this package's package overview docs 1534// for details on the service. 1535// 1536// InputService9ProtocolTest methods are safe to use concurrently. It is not safe to 1537// modify mutate any of the struct's properties though. 1538type InputService9ProtocolTest struct { 1539 *client.Client 1540} 1541 1542// New creates a new instance of the InputService9ProtocolTest client with a session. 1543// If additional configuration is needed for the client instance use the optional 1544// aws.Config parameter to add your extra config. 1545// 1546// Example: 1547// // Create a InputService9ProtocolTest client from just a session. 1548// svc := inputservice9protocoltest.New(mySession) 1549// 1550// // Create a InputService9ProtocolTest client with additional configuration 1551// svc := inputservice9protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1552func NewInputService9ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService9ProtocolTest { 1553 c := p.ClientConfig("inputservice9protocoltest", cfgs...) 1554 return newInputService9ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1555} 1556 1557// newClient creates, initializes and returns a new service client instance. 1558func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService9ProtocolTest { 1559 svc := &InputService9ProtocolTest{ 1560 Client: client.New( 1561 cfg, 1562 metadata.ClientInfo{ 1563 ServiceName: "inputservice9protocoltest", 1564 SigningName: signingName, 1565 SigningRegion: signingRegion, 1566 Endpoint: endpoint, 1567 APIVersion: "2014-01-01", 1568 }, 1569 handlers, 1570 ), 1571 } 1572 1573 // Handlers 1574 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1575 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1576 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1577 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1578 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1579 1580 return svc 1581} 1582 1583// newRequest creates a new request for a InputService9ProtocolTest operation and runs any 1584// custom request initialization. 1585func (c *InputService9ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1586 req := c.NewRequest(op, params, data) 1587 1588 return req 1589} 1590 1591const opInputService9TestCaseOperation1 = "OperationName" 1592 1593// InputService9TestCaseOperation1Request generates a "aws/request.Request" representing the 1594// client's request for the InputService9TestCaseOperation1 operation. The "output" return 1595// value will be populated with the request's response once the request complets 1596// successfuly. 1597// 1598// Use "Send" method on the returned Request to send the API call to the service. 1599// the "output" return value is not valid until after Send returns without error. 1600// 1601// See InputService9TestCaseOperation1 for more information on using the InputService9TestCaseOperation1 1602// API call, and error handling. 1603// 1604// This method is useful when you want to inject custom logic or configuration 1605// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1606// 1607// 1608// // Example sending a request using the InputService9TestCaseOperation1Request method. 1609// req, resp := client.InputService9TestCaseOperation1Request(params) 1610// 1611// err := req.Send() 1612// if err == nil { // resp is now filled 1613// fmt.Println(resp) 1614// } 1615func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input *InputService9TestShapeInputService9TestCaseOperation1Input) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation1Output) { 1616 op := &request.Operation{ 1617 Name: opInputService9TestCaseOperation1, 1618 HTTPMethod: "POST", 1619 HTTPPath: "/2014-01-01/hostedzone", 1620 } 1621 1622 if input == nil { 1623 input = &InputService9TestShapeInputService9TestCaseOperation1Input{} 1624 } 1625 1626 output = &InputService9TestShapeInputService9TestCaseOperation1Output{} 1627 req = c.newRequest(op, input, output) 1628 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 1629 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1630 return 1631} 1632 1633// InputService9TestCaseOperation1 API operation for . 1634// 1635// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1636// with awserr.Error's Code and Message methods to get detailed information about 1637// the error. 1638// 1639// See the AWS API reference guide for 's 1640// API operation InputService9TestCaseOperation1 for usage and error information. 1641func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *InputService9TestShapeInputService9TestCaseOperation1Input) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) { 1642 req, out := c.InputService9TestCaseOperation1Request(input) 1643 return out, req.Send() 1644} 1645 1646// InputService9TestCaseOperation1WithContext is the same as InputService9TestCaseOperation1 with the addition of 1647// the ability to pass a context and additional request options. 1648// 1649// See InputService9TestCaseOperation1 for details on how to use this API operation. 1650// 1651// The context must be non-nil and will be used for request cancellation. If 1652// the context is nil a panic will occur. In the future the SDK may create 1653// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1654// for more information on using Contexts. 1655func (c *InputService9ProtocolTest) InputService9TestCaseOperation1WithContext(ctx aws.Context, input *InputService9TestShapeInputService9TestCaseOperation1Input, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) { 1656 req, out := c.InputService9TestCaseOperation1Request(input) 1657 req.SetContext(ctx) 1658 req.ApplyOptions(opts...) 1659 return out, req.Send() 1660} 1661 1662type InputService9TestShapeInputService9TestCaseOperation1Input struct { 1663 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 1664 1665 ListParam []*InputService9TestShapeSingleFieldStruct `locationName:"item" type:"list" flattened:"true"` 1666} 1667 1668// SetListParam sets the ListParam field's value. 1669func (s *InputService9TestShapeInputService9TestCaseOperation1Input) SetListParam(v []*InputService9TestShapeSingleFieldStruct) *InputService9TestShapeInputService9TestCaseOperation1Input { 1670 s.ListParam = v 1671 return s 1672} 1673 1674type InputService9TestShapeInputService9TestCaseOperation1Output struct { 1675 _ struct{} `type:"structure"` 1676} 1677 1678type InputService9TestShapeSingleFieldStruct struct { 1679 _ struct{} `type:"structure"` 1680 1681 Element *string `locationName:"value" type:"string"` 1682} 1683 1684// SetElement sets the Element field's value. 1685func (s *InputService9TestShapeSingleFieldStruct) SetElement(v string) *InputService9TestShapeSingleFieldStruct { 1686 s.Element = &v 1687 return s 1688} 1689 1690// InputService10ProtocolTest provides the API operation methods for making requests to 1691// . See this package's package overview docs 1692// for details on the service. 1693// 1694// InputService10ProtocolTest methods are safe to use concurrently. It is not safe to 1695// modify mutate any of the struct's properties though. 1696type InputService10ProtocolTest struct { 1697 *client.Client 1698} 1699 1700// New creates a new instance of the InputService10ProtocolTest client with a session. 1701// If additional configuration is needed for the client instance use the optional 1702// aws.Config parameter to add your extra config. 1703// 1704// Example: 1705// // Create a InputService10ProtocolTest client from just a session. 1706// svc := inputservice10protocoltest.New(mySession) 1707// 1708// // Create a InputService10ProtocolTest client with additional configuration 1709// svc := inputservice10protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1710func NewInputService10ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService10ProtocolTest { 1711 c := p.ClientConfig("inputservice10protocoltest", cfgs...) 1712 return newInputService10ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1713} 1714 1715// newClient creates, initializes and returns a new service client instance. 1716func newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService10ProtocolTest { 1717 svc := &InputService10ProtocolTest{ 1718 Client: client.New( 1719 cfg, 1720 metadata.ClientInfo{ 1721 ServiceName: "inputservice10protocoltest", 1722 SigningName: signingName, 1723 SigningRegion: signingRegion, 1724 Endpoint: endpoint, 1725 APIVersion: "2014-01-01", 1726 }, 1727 handlers, 1728 ), 1729 } 1730 1731 // Handlers 1732 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1733 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1734 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1735 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1736 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1737 1738 return svc 1739} 1740 1741// newRequest creates a new request for a InputService10ProtocolTest operation and runs any 1742// custom request initialization. 1743func (c *InputService10ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1744 req := c.NewRequest(op, params, data) 1745 1746 return req 1747} 1748 1749const opInputService10TestCaseOperation1 = "OperationName" 1750 1751// InputService10TestCaseOperation1Request generates a "aws/request.Request" representing the 1752// client's request for the InputService10TestCaseOperation1 operation. The "output" return 1753// value will be populated with the request's response once the request complets 1754// successfuly. 1755// 1756// Use "Send" method on the returned Request to send the API call to the service. 1757// the "output" return value is not valid until after Send returns without error. 1758// 1759// See InputService10TestCaseOperation1 for more information on using the InputService10TestCaseOperation1 1760// API call, and error handling. 1761// 1762// This method is useful when you want to inject custom logic or configuration 1763// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1764// 1765// 1766// // Example sending a request using the InputService10TestCaseOperation1Request method. 1767// req, resp := client.InputService10TestCaseOperation1Request(params) 1768// 1769// err := req.Send() 1770// if err == nil { // resp is now filled 1771// fmt.Println(resp) 1772// } 1773func (c *InputService10ProtocolTest) InputService10TestCaseOperation1Request(input *InputService10TestShapeInputService10TestCaseOperation1Input) (req *request.Request, output *InputService10TestShapeInputService10TestCaseOperation1Output) { 1774 op := &request.Operation{ 1775 Name: opInputService10TestCaseOperation1, 1776 HTTPMethod: "POST", 1777 HTTPPath: "/2014-01-01/hostedzone", 1778 } 1779 1780 if input == nil { 1781 input = &InputService10TestShapeInputService10TestCaseOperation1Input{} 1782 } 1783 1784 output = &InputService10TestShapeInputService10TestCaseOperation1Output{} 1785 req = c.newRequest(op, input, output) 1786 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 1787 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1788 return 1789} 1790 1791// InputService10TestCaseOperation1 API operation for . 1792// 1793// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1794// with awserr.Error's Code and Message methods to get detailed information about 1795// the error. 1796// 1797// See the AWS API reference guide for 's 1798// API operation InputService10TestCaseOperation1 for usage and error information. 1799func (c *InputService10ProtocolTest) InputService10TestCaseOperation1(input *InputService10TestShapeInputService10TestCaseOperation1Input) (*InputService10TestShapeInputService10TestCaseOperation1Output, error) { 1800 req, out := c.InputService10TestCaseOperation1Request(input) 1801 return out, req.Send() 1802} 1803 1804// InputService10TestCaseOperation1WithContext is the same as InputService10TestCaseOperation1 with the addition of 1805// the ability to pass a context and additional request options. 1806// 1807// See InputService10TestCaseOperation1 for details on how to use this API operation. 1808// 1809// The context must be non-nil and will be used for request cancellation. If 1810// the context is nil a panic will occur. In the future the SDK may create 1811// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1812// for more information on using Contexts. 1813func (c *InputService10ProtocolTest) InputService10TestCaseOperation1WithContext(ctx aws.Context, input *InputService10TestShapeInputService10TestCaseOperation1Input, opts ...request.Option) (*InputService10TestShapeInputService10TestCaseOperation1Output, error) { 1814 req, out := c.InputService10TestCaseOperation1Request(input) 1815 req.SetContext(ctx) 1816 req.ApplyOptions(opts...) 1817 return out, req.Send() 1818} 1819 1820type InputService10TestShapeInputService10TestCaseOperation1Input struct { 1821 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 1822 1823 StructureParam *InputService10TestShapeStructureShape `type:"structure"` 1824} 1825 1826// SetStructureParam sets the StructureParam field's value. 1827func (s *InputService10TestShapeInputService10TestCaseOperation1Input) SetStructureParam(v *InputService10TestShapeStructureShape) *InputService10TestShapeInputService10TestCaseOperation1Input { 1828 s.StructureParam = v 1829 return s 1830} 1831 1832type InputService10TestShapeInputService10TestCaseOperation1Output struct { 1833 _ struct{} `type:"structure"` 1834} 1835 1836type InputService10TestShapeStructureShape struct { 1837 _ struct{} `type:"structure"` 1838 1839 // B is automatically base64 encoded/decoded by the SDK. 1840 B []byte `locationName:"b" type:"blob"` 1841 1842 T *time.Time `locationName:"t" type:"timestamp" timestampFormat:"iso8601"` 1843} 1844 1845// SetB sets the B field's value. 1846func (s *InputService10TestShapeStructureShape) SetB(v []byte) *InputService10TestShapeStructureShape { 1847 s.B = v 1848 return s 1849} 1850 1851// SetT sets the T field's value. 1852func (s *InputService10TestShapeStructureShape) SetT(v time.Time) *InputService10TestShapeStructureShape { 1853 s.T = &v 1854 return s 1855} 1856 1857// InputService11ProtocolTest provides the API operation methods for making requests to 1858// . See this package's package overview docs 1859// for details on the service. 1860// 1861// InputService11ProtocolTest methods are safe to use concurrently. It is not safe to 1862// modify mutate any of the struct's properties though. 1863type InputService11ProtocolTest struct { 1864 *client.Client 1865} 1866 1867// New creates a new instance of the InputService11ProtocolTest client with a session. 1868// If additional configuration is needed for the client instance use the optional 1869// aws.Config parameter to add your extra config. 1870// 1871// Example: 1872// // Create a InputService11ProtocolTest client from just a session. 1873// svc := inputservice11protocoltest.New(mySession) 1874// 1875// // Create a InputService11ProtocolTest client with additional configuration 1876// svc := inputservice11protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1877func NewInputService11ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService11ProtocolTest { 1878 c := p.ClientConfig("inputservice11protocoltest", cfgs...) 1879 return newInputService11ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1880} 1881 1882// newClient creates, initializes and returns a new service client instance. 1883func newInputService11ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService11ProtocolTest { 1884 svc := &InputService11ProtocolTest{ 1885 Client: client.New( 1886 cfg, 1887 metadata.ClientInfo{ 1888 ServiceName: "inputservice11protocoltest", 1889 SigningName: signingName, 1890 SigningRegion: signingRegion, 1891 Endpoint: endpoint, 1892 APIVersion: "2014-01-01", 1893 }, 1894 handlers, 1895 ), 1896 } 1897 1898 // Handlers 1899 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1900 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1901 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1902 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1903 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1904 1905 return svc 1906} 1907 1908// newRequest creates a new request for a InputService11ProtocolTest operation and runs any 1909// custom request initialization. 1910func (c *InputService11ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1911 req := c.NewRequest(op, params, data) 1912 1913 return req 1914} 1915 1916const opInputService11TestCaseOperation1 = "OperationName" 1917 1918// InputService11TestCaseOperation1Request generates a "aws/request.Request" representing the 1919// client's request for the InputService11TestCaseOperation1 operation. The "output" return 1920// value will be populated with the request's response once the request complets 1921// successfuly. 1922// 1923// Use "Send" method on the returned Request to send the API call to the service. 1924// the "output" return value is not valid until after Send returns without error. 1925// 1926// See InputService11TestCaseOperation1 for more information on using the InputService11TestCaseOperation1 1927// API call, and error handling. 1928// 1929// This method is useful when you want to inject custom logic or configuration 1930// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1931// 1932// 1933// // Example sending a request using the InputService11TestCaseOperation1Request method. 1934// req, resp := client.InputService11TestCaseOperation1Request(params) 1935// 1936// err := req.Send() 1937// if err == nil { // resp is now filled 1938// fmt.Println(resp) 1939// } 1940func (c *InputService11ProtocolTest) InputService11TestCaseOperation1Request(input *InputService11TestShapeInputService11TestCaseOperation1Input) (req *request.Request, output *InputService11TestShapeInputService11TestCaseOperation1Output) { 1941 op := &request.Operation{ 1942 Name: opInputService11TestCaseOperation1, 1943 HTTPMethod: "POST", 1944 HTTPPath: "/", 1945 } 1946 1947 if input == nil { 1948 input = &InputService11TestShapeInputService11TestCaseOperation1Input{} 1949 } 1950 1951 output = &InputService11TestShapeInputService11TestCaseOperation1Output{} 1952 req = c.newRequest(op, input, output) 1953 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 1954 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1955 return 1956} 1957 1958// InputService11TestCaseOperation1 API operation for . 1959// 1960// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1961// with awserr.Error's Code and Message methods to get detailed information about 1962// the error. 1963// 1964// See the AWS API reference guide for 's 1965// API operation InputService11TestCaseOperation1 for usage and error information. 1966func (c *InputService11ProtocolTest) InputService11TestCaseOperation1(input *InputService11TestShapeInputService11TestCaseOperation1Input) (*InputService11TestShapeInputService11TestCaseOperation1Output, error) { 1967 req, out := c.InputService11TestCaseOperation1Request(input) 1968 return out, req.Send() 1969} 1970 1971// InputService11TestCaseOperation1WithContext is the same as InputService11TestCaseOperation1 with the addition of 1972// the ability to pass a context and additional request options. 1973// 1974// See InputService11TestCaseOperation1 for details on how to use this API operation. 1975// 1976// The context must be non-nil and will be used for request cancellation. If 1977// the context is nil a panic will occur. In the future the SDK may create 1978// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1979// for more information on using Contexts. 1980func (c *InputService11ProtocolTest) InputService11TestCaseOperation1WithContext(ctx aws.Context, input *InputService11TestShapeInputService11TestCaseOperation1Input, opts ...request.Option) (*InputService11TestShapeInputService11TestCaseOperation1Output, error) { 1981 req, out := c.InputService11TestCaseOperation1Request(input) 1982 req.SetContext(ctx) 1983 req.ApplyOptions(opts...) 1984 return out, req.Send() 1985} 1986 1987type InputService11TestShapeInputService11TestCaseOperation1Input struct { 1988 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 1989 1990 Foo map[string]*string `location:"headers" locationName:"x-foo-" type:"map"` 1991} 1992 1993// SetFoo sets the Foo field's value. 1994func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetFoo(v map[string]*string) *InputService11TestShapeInputService11TestCaseOperation1Input { 1995 s.Foo = v 1996 return s 1997} 1998 1999type InputService11TestShapeInputService11TestCaseOperation1Output struct { 2000 _ struct{} `type:"structure"` 2001} 2002 2003// InputService12ProtocolTest provides the API operation methods for making requests to 2004// . See this package's package overview docs 2005// for details on the service. 2006// 2007// InputService12ProtocolTest methods are safe to use concurrently. It is not safe to 2008// modify mutate any of the struct's properties though. 2009type InputService12ProtocolTest struct { 2010 *client.Client 2011} 2012 2013// New creates a new instance of the InputService12ProtocolTest client with a session. 2014// If additional configuration is needed for the client instance use the optional 2015// aws.Config parameter to add your extra config. 2016// 2017// Example: 2018// // Create a InputService12ProtocolTest client from just a session. 2019// svc := inputservice12protocoltest.New(mySession) 2020// 2021// // Create a InputService12ProtocolTest client with additional configuration 2022// svc := inputservice12protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2023func NewInputService12ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService12ProtocolTest { 2024 c := p.ClientConfig("inputservice12protocoltest", cfgs...) 2025 return newInputService12ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2026} 2027 2028// newClient creates, initializes and returns a new service client instance. 2029func newInputService12ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService12ProtocolTest { 2030 svc := &InputService12ProtocolTest{ 2031 Client: client.New( 2032 cfg, 2033 metadata.ClientInfo{ 2034 ServiceName: "inputservice12protocoltest", 2035 SigningName: signingName, 2036 SigningRegion: signingRegion, 2037 Endpoint: endpoint, 2038 APIVersion: "2014-01-01", 2039 }, 2040 handlers, 2041 ), 2042 } 2043 2044 // Handlers 2045 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2046 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 2047 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 2048 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 2049 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 2050 2051 return svc 2052} 2053 2054// newRequest creates a new request for a InputService12ProtocolTest operation and runs any 2055// custom request initialization. 2056func (c *InputService12ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2057 req := c.NewRequest(op, params, data) 2058 2059 return req 2060} 2061 2062const opInputService12TestCaseOperation1 = "OperationName" 2063 2064// InputService12TestCaseOperation1Request generates a "aws/request.Request" representing the 2065// client's request for the InputService12TestCaseOperation1 operation. The "output" return 2066// value will be populated with the request's response once the request complets 2067// successfuly. 2068// 2069// Use "Send" method on the returned Request to send the API call to the service. 2070// the "output" return value is not valid until after Send returns without error. 2071// 2072// See InputService12TestCaseOperation1 for more information on using the InputService12TestCaseOperation1 2073// API call, and error handling. 2074// 2075// This method is useful when you want to inject custom logic or configuration 2076// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2077// 2078// 2079// // Example sending a request using the InputService12TestCaseOperation1Request method. 2080// req, resp := client.InputService12TestCaseOperation1Request(params) 2081// 2082// err := req.Send() 2083// if err == nil { // resp is now filled 2084// fmt.Println(resp) 2085// } 2086func (c *InputService12ProtocolTest) InputService12TestCaseOperation1Request(input *InputService12TestShapeInputService12TestCaseOperation1Input) (req *request.Request, output *InputService12TestShapeInputService12TestCaseOperation1Output) { 2087 op := &request.Operation{ 2088 Name: opInputService12TestCaseOperation1, 2089 HTTPMethod: "GET", 2090 HTTPPath: "/path", 2091 } 2092 2093 if input == nil { 2094 input = &InputService12TestShapeInputService12TestCaseOperation1Input{} 2095 } 2096 2097 output = &InputService12TestShapeInputService12TestCaseOperation1Output{} 2098 req = c.newRequest(op, input, output) 2099 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 2100 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2101 return 2102} 2103 2104// InputService12TestCaseOperation1 API operation for . 2105// 2106// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2107// with awserr.Error's Code and Message methods to get detailed information about 2108// the error. 2109// 2110// See the AWS API reference guide for 's 2111// API operation InputService12TestCaseOperation1 for usage and error information. 2112func (c *InputService12ProtocolTest) InputService12TestCaseOperation1(input *InputService12TestShapeInputService12TestCaseOperation1Input) (*InputService12TestShapeInputService12TestCaseOperation1Output, error) { 2113 req, out := c.InputService12TestCaseOperation1Request(input) 2114 return out, req.Send() 2115} 2116 2117// InputService12TestCaseOperation1WithContext is the same as InputService12TestCaseOperation1 with the addition of 2118// the ability to pass a context and additional request options. 2119// 2120// See InputService12TestCaseOperation1 for details on how to use this API operation. 2121// 2122// The context must be non-nil and will be used for request cancellation. If 2123// the context is nil a panic will occur. In the future the SDK may create 2124// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2125// for more information on using Contexts. 2126func (c *InputService12ProtocolTest) InputService12TestCaseOperation1WithContext(ctx aws.Context, input *InputService12TestShapeInputService12TestCaseOperation1Input, opts ...request.Option) (*InputService12TestShapeInputService12TestCaseOperation1Output, error) { 2127 req, out := c.InputService12TestCaseOperation1Request(input) 2128 req.SetContext(ctx) 2129 req.ApplyOptions(opts...) 2130 return out, req.Send() 2131} 2132 2133type InputService12TestShapeInputService12TestCaseOperation1Input struct { 2134 _ struct{} `type:"structure"` 2135 2136 Items []*string `location:"querystring" locationName:"item" type:"list"` 2137} 2138 2139// SetItems sets the Items field's value. 2140func (s *InputService12TestShapeInputService12TestCaseOperation1Input) SetItems(v []*string) *InputService12TestShapeInputService12TestCaseOperation1Input { 2141 s.Items = v 2142 return s 2143} 2144 2145type InputService12TestShapeInputService12TestCaseOperation1Output struct { 2146 _ struct{} `type:"structure"` 2147} 2148 2149// InputService13ProtocolTest provides the API operation methods for making requests to 2150// . See this package's package overview docs 2151// for details on the service. 2152// 2153// InputService13ProtocolTest methods are safe to use concurrently. It is not safe to 2154// modify mutate any of the struct's properties though. 2155type InputService13ProtocolTest struct { 2156 *client.Client 2157} 2158 2159// New creates a new instance of the InputService13ProtocolTest client with a session. 2160// If additional configuration is needed for the client instance use the optional 2161// aws.Config parameter to add your extra config. 2162// 2163// Example: 2164// // Create a InputService13ProtocolTest client from just a session. 2165// svc := inputservice13protocoltest.New(mySession) 2166// 2167// // Create a InputService13ProtocolTest client with additional configuration 2168// svc := inputservice13protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2169func NewInputService13ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService13ProtocolTest { 2170 c := p.ClientConfig("inputservice13protocoltest", cfgs...) 2171 return newInputService13ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2172} 2173 2174// newClient creates, initializes and returns a new service client instance. 2175func newInputService13ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService13ProtocolTest { 2176 svc := &InputService13ProtocolTest{ 2177 Client: client.New( 2178 cfg, 2179 metadata.ClientInfo{ 2180 ServiceName: "inputservice13protocoltest", 2181 SigningName: signingName, 2182 SigningRegion: signingRegion, 2183 Endpoint: endpoint, 2184 APIVersion: "2014-01-01", 2185 }, 2186 handlers, 2187 ), 2188 } 2189 2190 // Handlers 2191 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2192 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 2193 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 2194 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 2195 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 2196 2197 return svc 2198} 2199 2200// newRequest creates a new request for a InputService13ProtocolTest operation and runs any 2201// custom request initialization. 2202func (c *InputService13ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2203 req := c.NewRequest(op, params, data) 2204 2205 return req 2206} 2207 2208const opInputService13TestCaseOperation1 = "OperationName" 2209 2210// InputService13TestCaseOperation1Request generates a "aws/request.Request" representing the 2211// client's request for the InputService13TestCaseOperation1 operation. The "output" return 2212// value will be populated with the request's response once the request complets 2213// successfuly. 2214// 2215// Use "Send" method on the returned Request to send the API call to the service. 2216// the "output" return value is not valid until after Send returns without error. 2217// 2218// See InputService13TestCaseOperation1 for more information on using the InputService13TestCaseOperation1 2219// API call, and error handling. 2220// 2221// This method is useful when you want to inject custom logic or configuration 2222// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2223// 2224// 2225// // Example sending a request using the InputService13TestCaseOperation1Request method. 2226// req, resp := client.InputService13TestCaseOperation1Request(params) 2227// 2228// err := req.Send() 2229// if err == nil { // resp is now filled 2230// fmt.Println(resp) 2231// } 2232func (c *InputService13ProtocolTest) InputService13TestCaseOperation1Request(input *InputService13TestShapeInputService13TestCaseOperation1Input) (req *request.Request, output *InputService13TestShapeInputService13TestCaseOperation1Output) { 2233 op := &request.Operation{ 2234 Name: opInputService13TestCaseOperation1, 2235 HTTPMethod: "GET", 2236 HTTPPath: "/2014-01-01/jobsByPipeline/{PipelineId}", 2237 } 2238 2239 if input == nil { 2240 input = &InputService13TestShapeInputService13TestCaseOperation1Input{} 2241 } 2242 2243 output = &InputService13TestShapeInputService13TestCaseOperation1Output{} 2244 req = c.newRequest(op, input, output) 2245 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 2246 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2247 return 2248} 2249 2250// InputService13TestCaseOperation1 API operation for . 2251// 2252// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2253// with awserr.Error's Code and Message methods to get detailed information about 2254// the error. 2255// 2256// See the AWS API reference guide for 's 2257// API operation InputService13TestCaseOperation1 for usage and error information. 2258func (c *InputService13ProtocolTest) InputService13TestCaseOperation1(input *InputService13TestShapeInputService13TestCaseOperation1Input) (*InputService13TestShapeInputService13TestCaseOperation1Output, error) { 2259 req, out := c.InputService13TestCaseOperation1Request(input) 2260 return out, req.Send() 2261} 2262 2263// InputService13TestCaseOperation1WithContext is the same as InputService13TestCaseOperation1 with the addition of 2264// the ability to pass a context and additional request options. 2265// 2266// See InputService13TestCaseOperation1 for details on how to use this API operation. 2267// 2268// The context must be non-nil and will be used for request cancellation. If 2269// the context is nil a panic will occur. In the future the SDK may create 2270// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2271// for more information on using Contexts. 2272func (c *InputService13ProtocolTest) InputService13TestCaseOperation1WithContext(ctx aws.Context, input *InputService13TestShapeInputService13TestCaseOperation1Input, opts ...request.Option) (*InputService13TestShapeInputService13TestCaseOperation1Output, error) { 2273 req, out := c.InputService13TestCaseOperation1Request(input) 2274 req.SetContext(ctx) 2275 req.ApplyOptions(opts...) 2276 return out, req.Send() 2277} 2278 2279type InputService13TestShapeInputService13TestCaseOperation1Input struct { 2280 _ struct{} `type:"structure"` 2281 2282 PipelineId *string `location:"uri" type:"string"` 2283 2284 QueryDoc map[string]*string `location:"querystring" type:"map"` 2285} 2286 2287// SetPipelineId sets the PipelineId field's value. 2288func (s *InputService13TestShapeInputService13TestCaseOperation1Input) SetPipelineId(v string) *InputService13TestShapeInputService13TestCaseOperation1Input { 2289 s.PipelineId = &v 2290 return s 2291} 2292 2293// SetQueryDoc sets the QueryDoc field's value. 2294func (s *InputService13TestShapeInputService13TestCaseOperation1Input) SetQueryDoc(v map[string]*string) *InputService13TestShapeInputService13TestCaseOperation1Input { 2295 s.QueryDoc = v 2296 return s 2297} 2298 2299type InputService13TestShapeInputService13TestCaseOperation1Output struct { 2300 _ struct{} `type:"structure"` 2301} 2302 2303// InputService14ProtocolTest provides the API operation methods for making requests to 2304// . See this package's package overview docs 2305// for details on the service. 2306// 2307// InputService14ProtocolTest methods are safe to use concurrently. It is not safe to 2308// modify mutate any of the struct's properties though. 2309type InputService14ProtocolTest struct { 2310 *client.Client 2311} 2312 2313// New creates a new instance of the InputService14ProtocolTest client with a session. 2314// If additional configuration is needed for the client instance use the optional 2315// aws.Config parameter to add your extra config. 2316// 2317// Example: 2318// // Create a InputService14ProtocolTest client from just a session. 2319// svc := inputservice14protocoltest.New(mySession) 2320// 2321// // Create a InputService14ProtocolTest client with additional configuration 2322// svc := inputservice14protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2323func NewInputService14ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService14ProtocolTest { 2324 c := p.ClientConfig("inputservice14protocoltest", cfgs...) 2325 return newInputService14ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2326} 2327 2328// newClient creates, initializes and returns a new service client instance. 2329func newInputService14ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService14ProtocolTest { 2330 svc := &InputService14ProtocolTest{ 2331 Client: client.New( 2332 cfg, 2333 metadata.ClientInfo{ 2334 ServiceName: "inputservice14protocoltest", 2335 SigningName: signingName, 2336 SigningRegion: signingRegion, 2337 Endpoint: endpoint, 2338 APIVersion: "2014-01-01", 2339 }, 2340 handlers, 2341 ), 2342 } 2343 2344 // Handlers 2345 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2346 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 2347 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 2348 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 2349 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 2350 2351 return svc 2352} 2353 2354// newRequest creates a new request for a InputService14ProtocolTest operation and runs any 2355// custom request initialization. 2356func (c *InputService14ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2357 req := c.NewRequest(op, params, data) 2358 2359 return req 2360} 2361 2362const opInputService14TestCaseOperation1 = "OperationName" 2363 2364// InputService14TestCaseOperation1Request generates a "aws/request.Request" representing the 2365// client's request for the InputService14TestCaseOperation1 operation. The "output" return 2366// value will be populated with the request's response once the request complets 2367// successfuly. 2368// 2369// Use "Send" method on the returned Request to send the API call to the service. 2370// the "output" return value is not valid until after Send returns without error. 2371// 2372// See InputService14TestCaseOperation1 for more information on using the InputService14TestCaseOperation1 2373// API call, and error handling. 2374// 2375// This method is useful when you want to inject custom logic or configuration 2376// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2377// 2378// 2379// // Example sending a request using the InputService14TestCaseOperation1Request method. 2380// req, resp := client.InputService14TestCaseOperation1Request(params) 2381// 2382// err := req.Send() 2383// if err == nil { // resp is now filled 2384// fmt.Println(resp) 2385// } 2386func (c *InputService14ProtocolTest) InputService14TestCaseOperation1Request(input *InputService14TestShapeInputService14TestCaseOperation1Input) (req *request.Request, output *InputService14TestShapeInputService14TestCaseOperation1Output) { 2387 op := &request.Operation{ 2388 Name: opInputService14TestCaseOperation1, 2389 HTTPMethod: "GET", 2390 HTTPPath: "/2014-01-01/jobsByPipeline/{PipelineId}", 2391 } 2392 2393 if input == nil { 2394 input = &InputService14TestShapeInputService14TestCaseOperation1Input{} 2395 } 2396 2397 output = &InputService14TestShapeInputService14TestCaseOperation1Output{} 2398 req = c.newRequest(op, input, output) 2399 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 2400 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2401 return 2402} 2403 2404// InputService14TestCaseOperation1 API operation for . 2405// 2406// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2407// with awserr.Error's Code and Message methods to get detailed information about 2408// the error. 2409// 2410// See the AWS API reference guide for 's 2411// API operation InputService14TestCaseOperation1 for usage and error information. 2412func (c *InputService14ProtocolTest) InputService14TestCaseOperation1(input *InputService14TestShapeInputService14TestCaseOperation1Input) (*InputService14TestShapeInputService14TestCaseOperation1Output, error) { 2413 req, out := c.InputService14TestCaseOperation1Request(input) 2414 return out, req.Send() 2415} 2416 2417// InputService14TestCaseOperation1WithContext is the same as InputService14TestCaseOperation1 with the addition of 2418// the ability to pass a context and additional request options. 2419// 2420// See InputService14TestCaseOperation1 for details on how to use this API operation. 2421// 2422// The context must be non-nil and will be used for request cancellation. If 2423// the context is nil a panic will occur. In the future the SDK may create 2424// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2425// for more information on using Contexts. 2426func (c *InputService14ProtocolTest) InputService14TestCaseOperation1WithContext(ctx aws.Context, input *InputService14TestShapeInputService14TestCaseOperation1Input, opts ...request.Option) (*InputService14TestShapeInputService14TestCaseOperation1Output, error) { 2427 req, out := c.InputService14TestCaseOperation1Request(input) 2428 req.SetContext(ctx) 2429 req.ApplyOptions(opts...) 2430 return out, req.Send() 2431} 2432 2433type InputService14TestShapeInputService14TestCaseOperation1Input struct { 2434 _ struct{} `type:"structure"` 2435 2436 PipelineId *string `location:"uri" type:"string"` 2437 2438 QueryDoc map[string][]*string `location:"querystring" type:"map"` 2439} 2440 2441// SetPipelineId sets the PipelineId field's value. 2442func (s *InputService14TestShapeInputService14TestCaseOperation1Input) SetPipelineId(v string) *InputService14TestShapeInputService14TestCaseOperation1Input { 2443 s.PipelineId = &v 2444 return s 2445} 2446 2447// SetQueryDoc sets the QueryDoc field's value. 2448func (s *InputService14TestShapeInputService14TestCaseOperation1Input) SetQueryDoc(v map[string][]*string) *InputService14TestShapeInputService14TestCaseOperation1Input { 2449 s.QueryDoc = v 2450 return s 2451} 2452 2453type InputService14TestShapeInputService14TestCaseOperation1Output struct { 2454 _ struct{} `type:"structure"` 2455} 2456 2457// InputService15ProtocolTest provides the API operation methods for making requests to 2458// . See this package's package overview docs 2459// for details on the service. 2460// 2461// InputService15ProtocolTest methods are safe to use concurrently. It is not safe to 2462// modify mutate any of the struct's properties though. 2463type InputService15ProtocolTest struct { 2464 *client.Client 2465} 2466 2467// New creates a new instance of the InputService15ProtocolTest client with a session. 2468// If additional configuration is needed for the client instance use the optional 2469// aws.Config parameter to add your extra config. 2470// 2471// Example: 2472// // Create a InputService15ProtocolTest client from just a session. 2473// svc := inputservice15protocoltest.New(mySession) 2474// 2475// // Create a InputService15ProtocolTest client with additional configuration 2476// svc := inputservice15protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2477func NewInputService15ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService15ProtocolTest { 2478 c := p.ClientConfig("inputservice15protocoltest", cfgs...) 2479 return newInputService15ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2480} 2481 2482// newClient creates, initializes and returns a new service client instance. 2483func newInputService15ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService15ProtocolTest { 2484 svc := &InputService15ProtocolTest{ 2485 Client: client.New( 2486 cfg, 2487 metadata.ClientInfo{ 2488 ServiceName: "inputservice15protocoltest", 2489 SigningName: signingName, 2490 SigningRegion: signingRegion, 2491 Endpoint: endpoint, 2492 APIVersion: "2014-01-01", 2493 }, 2494 handlers, 2495 ), 2496 } 2497 2498 // Handlers 2499 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2500 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 2501 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 2502 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 2503 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 2504 2505 return svc 2506} 2507 2508// newRequest creates a new request for a InputService15ProtocolTest operation and runs any 2509// custom request initialization. 2510func (c *InputService15ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2511 req := c.NewRequest(op, params, data) 2512 2513 return req 2514} 2515 2516const opInputService15TestCaseOperation1 = "OperationName" 2517 2518// InputService15TestCaseOperation1Request generates a "aws/request.Request" representing the 2519// client's request for the InputService15TestCaseOperation1 operation. The "output" return 2520// value will be populated with the request's response once the request complets 2521// successfuly. 2522// 2523// Use "Send" method on the returned Request to send the API call to the service. 2524// the "output" return value is not valid until after Send returns without error. 2525// 2526// See InputService15TestCaseOperation1 for more information on using the InputService15TestCaseOperation1 2527// API call, and error handling. 2528// 2529// This method is useful when you want to inject custom logic or configuration 2530// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2531// 2532// 2533// // Example sending a request using the InputService15TestCaseOperation1Request method. 2534// req, resp := client.InputService15TestCaseOperation1Request(params) 2535// 2536// err := req.Send() 2537// if err == nil { // resp is now filled 2538// fmt.Println(resp) 2539// } 2540func (c *InputService15ProtocolTest) InputService15TestCaseOperation1Request(input *InputService15TestShapeInputService15TestCaseOperation2Input) (req *request.Request, output *InputService15TestShapeInputService15TestCaseOperation1Output) { 2541 op := &request.Operation{ 2542 Name: opInputService15TestCaseOperation1, 2543 HTTPMethod: "GET", 2544 HTTPPath: "/path", 2545 } 2546 2547 if input == nil { 2548 input = &InputService15TestShapeInputService15TestCaseOperation2Input{} 2549 } 2550 2551 output = &InputService15TestShapeInputService15TestCaseOperation1Output{} 2552 req = c.newRequest(op, input, output) 2553 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 2554 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2555 return 2556} 2557 2558// InputService15TestCaseOperation1 API operation for . 2559// 2560// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2561// with awserr.Error's Code and Message methods to get detailed information about 2562// the error. 2563// 2564// See the AWS API reference guide for 's 2565// API operation InputService15TestCaseOperation1 for usage and error information. 2566func (c *InputService15ProtocolTest) InputService15TestCaseOperation1(input *InputService15TestShapeInputService15TestCaseOperation2Input) (*InputService15TestShapeInputService15TestCaseOperation1Output, error) { 2567 req, out := c.InputService15TestCaseOperation1Request(input) 2568 return out, req.Send() 2569} 2570 2571// InputService15TestCaseOperation1WithContext is the same as InputService15TestCaseOperation1 with the addition of 2572// the ability to pass a context and additional request options. 2573// 2574// See InputService15TestCaseOperation1 for details on how to use this API operation. 2575// 2576// The context must be non-nil and will be used for request cancellation. If 2577// the context is nil a panic will occur. In the future the SDK may create 2578// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2579// for more information on using Contexts. 2580func (c *InputService15ProtocolTest) InputService15TestCaseOperation1WithContext(ctx aws.Context, input *InputService15TestShapeInputService15TestCaseOperation2Input, opts ...request.Option) (*InputService15TestShapeInputService15TestCaseOperation1Output, error) { 2581 req, out := c.InputService15TestCaseOperation1Request(input) 2582 req.SetContext(ctx) 2583 req.ApplyOptions(opts...) 2584 return out, req.Send() 2585} 2586 2587const opInputService15TestCaseOperation2 = "OperationName" 2588 2589// InputService15TestCaseOperation2Request generates a "aws/request.Request" representing the 2590// client's request for the InputService15TestCaseOperation2 operation. The "output" return 2591// value will be populated with the request's response once the request complets 2592// successfuly. 2593// 2594// Use "Send" method on the returned Request to send the API call to the service. 2595// the "output" return value is not valid until after Send returns without error. 2596// 2597// See InputService15TestCaseOperation2 for more information on using the InputService15TestCaseOperation2 2598// API call, and error handling. 2599// 2600// This method is useful when you want to inject custom logic or configuration 2601// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2602// 2603// 2604// // Example sending a request using the InputService15TestCaseOperation2Request method. 2605// req, resp := client.InputService15TestCaseOperation2Request(params) 2606// 2607// err := req.Send() 2608// if err == nil { // resp is now filled 2609// fmt.Println(resp) 2610// } 2611func (c *InputService15ProtocolTest) InputService15TestCaseOperation2Request(input *InputService15TestShapeInputService15TestCaseOperation2Input) (req *request.Request, output *InputService15TestShapeInputService15TestCaseOperation2Output) { 2612 op := &request.Operation{ 2613 Name: opInputService15TestCaseOperation2, 2614 HTTPMethod: "GET", 2615 HTTPPath: "/path", 2616 } 2617 2618 if input == nil { 2619 input = &InputService15TestShapeInputService15TestCaseOperation2Input{} 2620 } 2621 2622 output = &InputService15TestShapeInputService15TestCaseOperation2Output{} 2623 req = c.newRequest(op, input, output) 2624 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 2625 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2626 return 2627} 2628 2629// InputService15TestCaseOperation2 API operation for . 2630// 2631// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2632// with awserr.Error's Code and Message methods to get detailed information about 2633// the error. 2634// 2635// See the AWS API reference guide for 's 2636// API operation InputService15TestCaseOperation2 for usage and error information. 2637func (c *InputService15ProtocolTest) InputService15TestCaseOperation2(input *InputService15TestShapeInputService15TestCaseOperation2Input) (*InputService15TestShapeInputService15TestCaseOperation2Output, error) { 2638 req, out := c.InputService15TestCaseOperation2Request(input) 2639 return out, req.Send() 2640} 2641 2642// InputService15TestCaseOperation2WithContext is the same as InputService15TestCaseOperation2 with the addition of 2643// the ability to pass a context and additional request options. 2644// 2645// See InputService15TestCaseOperation2 for details on how to use this API operation. 2646// 2647// The context must be non-nil and will be used for request cancellation. If 2648// the context is nil a panic will occur. In the future the SDK may create 2649// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2650// for more information on using Contexts. 2651func (c *InputService15ProtocolTest) InputService15TestCaseOperation2WithContext(ctx aws.Context, input *InputService15TestShapeInputService15TestCaseOperation2Input, opts ...request.Option) (*InputService15TestShapeInputService15TestCaseOperation2Output, error) { 2652 req, out := c.InputService15TestCaseOperation2Request(input) 2653 req.SetContext(ctx) 2654 req.ApplyOptions(opts...) 2655 return out, req.Send() 2656} 2657 2658type InputService15TestShapeInputService15TestCaseOperation1Output struct { 2659 _ struct{} `type:"structure"` 2660} 2661 2662type InputService15TestShapeInputService15TestCaseOperation2Input struct { 2663 _ struct{} `type:"structure"` 2664 2665 BoolQuery *bool `location:"querystring" locationName:"bool-query" type:"boolean"` 2666} 2667 2668// SetBoolQuery sets the BoolQuery field's value. 2669func (s *InputService15TestShapeInputService15TestCaseOperation2Input) SetBoolQuery(v bool) *InputService15TestShapeInputService15TestCaseOperation2Input { 2670 s.BoolQuery = &v 2671 return s 2672} 2673 2674type InputService15TestShapeInputService15TestCaseOperation2Output struct { 2675 _ struct{} `type:"structure"` 2676} 2677 2678// InputService16ProtocolTest provides the API operation methods for making requests to 2679// . See this package's package overview docs 2680// for details on the service. 2681// 2682// InputService16ProtocolTest methods are safe to use concurrently. It is not safe to 2683// modify mutate any of the struct's properties though. 2684type InputService16ProtocolTest struct { 2685 *client.Client 2686} 2687 2688// New creates a new instance of the InputService16ProtocolTest client with a session. 2689// If additional configuration is needed for the client instance use the optional 2690// aws.Config parameter to add your extra config. 2691// 2692// Example: 2693// // Create a InputService16ProtocolTest client from just a session. 2694// svc := inputservice16protocoltest.New(mySession) 2695// 2696// // Create a InputService16ProtocolTest client with additional configuration 2697// svc := inputservice16protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2698func NewInputService16ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService16ProtocolTest { 2699 c := p.ClientConfig("inputservice16protocoltest", cfgs...) 2700 return newInputService16ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2701} 2702 2703// newClient creates, initializes and returns a new service client instance. 2704func newInputService16ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService16ProtocolTest { 2705 svc := &InputService16ProtocolTest{ 2706 Client: client.New( 2707 cfg, 2708 metadata.ClientInfo{ 2709 ServiceName: "inputservice16protocoltest", 2710 SigningName: signingName, 2711 SigningRegion: signingRegion, 2712 Endpoint: endpoint, 2713 APIVersion: "2014-01-01", 2714 }, 2715 handlers, 2716 ), 2717 } 2718 2719 // Handlers 2720 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2721 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 2722 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 2723 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 2724 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 2725 2726 return svc 2727} 2728 2729// newRequest creates a new request for a InputService16ProtocolTest operation and runs any 2730// custom request initialization. 2731func (c *InputService16ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2732 req := c.NewRequest(op, params, data) 2733 2734 return req 2735} 2736 2737const opInputService16TestCaseOperation1 = "OperationName" 2738 2739// InputService16TestCaseOperation1Request generates a "aws/request.Request" representing the 2740// client's request for the InputService16TestCaseOperation1 operation. The "output" return 2741// value will be populated with the request's response once the request complets 2742// successfuly. 2743// 2744// Use "Send" method on the returned Request to send the API call to the service. 2745// the "output" return value is not valid until after Send returns without error. 2746// 2747// See InputService16TestCaseOperation1 for more information on using the InputService16TestCaseOperation1 2748// API call, and error handling. 2749// 2750// This method is useful when you want to inject custom logic or configuration 2751// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2752// 2753// 2754// // Example sending a request using the InputService16TestCaseOperation1Request method. 2755// req, resp := client.InputService16TestCaseOperation1Request(params) 2756// 2757// err := req.Send() 2758// if err == nil { // resp is now filled 2759// fmt.Println(resp) 2760// } 2761func (c *InputService16ProtocolTest) InputService16TestCaseOperation1Request(input *InputService16TestShapeInputService16TestCaseOperation1Input) (req *request.Request, output *InputService16TestShapeInputService16TestCaseOperation1Output) { 2762 op := &request.Operation{ 2763 Name: opInputService16TestCaseOperation1, 2764 HTTPMethod: "POST", 2765 HTTPPath: "/", 2766 } 2767 2768 if input == nil { 2769 input = &InputService16TestShapeInputService16TestCaseOperation1Input{} 2770 } 2771 2772 output = &InputService16TestShapeInputService16TestCaseOperation1Output{} 2773 req = c.newRequest(op, input, output) 2774 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 2775 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2776 return 2777} 2778 2779// InputService16TestCaseOperation1 API operation for . 2780// 2781// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2782// with awserr.Error's Code and Message methods to get detailed information about 2783// the error. 2784// 2785// See the AWS API reference guide for 's 2786// API operation InputService16TestCaseOperation1 for usage and error information. 2787func (c *InputService16ProtocolTest) InputService16TestCaseOperation1(input *InputService16TestShapeInputService16TestCaseOperation1Input) (*InputService16TestShapeInputService16TestCaseOperation1Output, error) { 2788 req, out := c.InputService16TestCaseOperation1Request(input) 2789 return out, req.Send() 2790} 2791 2792// InputService16TestCaseOperation1WithContext is the same as InputService16TestCaseOperation1 with the addition of 2793// the ability to pass a context and additional request options. 2794// 2795// See InputService16TestCaseOperation1 for details on how to use this API operation. 2796// 2797// The context must be non-nil and will be used for request cancellation. If 2798// the context is nil a panic will occur. In the future the SDK may create 2799// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2800// for more information on using Contexts. 2801func (c *InputService16ProtocolTest) InputService16TestCaseOperation1WithContext(ctx aws.Context, input *InputService16TestShapeInputService16TestCaseOperation1Input, opts ...request.Option) (*InputService16TestShapeInputService16TestCaseOperation1Output, error) { 2802 req, out := c.InputService16TestCaseOperation1Request(input) 2803 req.SetContext(ctx) 2804 req.ApplyOptions(opts...) 2805 return out, req.Send() 2806} 2807 2808type InputService16TestShapeInputService16TestCaseOperation1Input struct { 2809 _ struct{} `type:"structure" payload:"Foo"` 2810 2811 Foo *string `locationName:"foo" type:"string"` 2812} 2813 2814// SetFoo sets the Foo field's value. 2815func (s *InputService16TestShapeInputService16TestCaseOperation1Input) SetFoo(v string) *InputService16TestShapeInputService16TestCaseOperation1Input { 2816 s.Foo = &v 2817 return s 2818} 2819 2820type InputService16TestShapeInputService16TestCaseOperation1Output struct { 2821 _ struct{} `type:"structure"` 2822} 2823 2824// InputService17ProtocolTest provides the API operation methods for making requests to 2825// . See this package's package overview docs 2826// for details on the service. 2827// 2828// InputService17ProtocolTest methods are safe to use concurrently. It is not safe to 2829// modify mutate any of the struct's properties though. 2830type InputService17ProtocolTest struct { 2831 *client.Client 2832} 2833 2834// New creates a new instance of the InputService17ProtocolTest client with a session. 2835// If additional configuration is needed for the client instance use the optional 2836// aws.Config parameter to add your extra config. 2837// 2838// Example: 2839// // Create a InputService17ProtocolTest client from just a session. 2840// svc := inputservice17protocoltest.New(mySession) 2841// 2842// // Create a InputService17ProtocolTest client with additional configuration 2843// svc := inputservice17protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2844func NewInputService17ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService17ProtocolTest { 2845 c := p.ClientConfig("inputservice17protocoltest", cfgs...) 2846 return newInputService17ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2847} 2848 2849// newClient creates, initializes and returns a new service client instance. 2850func newInputService17ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService17ProtocolTest { 2851 svc := &InputService17ProtocolTest{ 2852 Client: client.New( 2853 cfg, 2854 metadata.ClientInfo{ 2855 ServiceName: "inputservice17protocoltest", 2856 SigningName: signingName, 2857 SigningRegion: signingRegion, 2858 Endpoint: endpoint, 2859 APIVersion: "2014-01-01", 2860 }, 2861 handlers, 2862 ), 2863 } 2864 2865 // Handlers 2866 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2867 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 2868 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 2869 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 2870 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 2871 2872 return svc 2873} 2874 2875// newRequest creates a new request for a InputService17ProtocolTest operation and runs any 2876// custom request initialization. 2877func (c *InputService17ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2878 req := c.NewRequest(op, params, data) 2879 2880 return req 2881} 2882 2883const opInputService17TestCaseOperation1 = "OperationName" 2884 2885// InputService17TestCaseOperation1Request generates a "aws/request.Request" representing the 2886// client's request for the InputService17TestCaseOperation1 operation. The "output" return 2887// value will be populated with the request's response once the request complets 2888// successfuly. 2889// 2890// Use "Send" method on the returned Request to send the API call to the service. 2891// the "output" return value is not valid until after Send returns without error. 2892// 2893// See InputService17TestCaseOperation1 for more information on using the InputService17TestCaseOperation1 2894// API call, and error handling. 2895// 2896// This method is useful when you want to inject custom logic or configuration 2897// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2898// 2899// 2900// // Example sending a request using the InputService17TestCaseOperation1Request method. 2901// req, resp := client.InputService17TestCaseOperation1Request(params) 2902// 2903// err := req.Send() 2904// if err == nil { // resp is now filled 2905// fmt.Println(resp) 2906// } 2907func (c *InputService17ProtocolTest) InputService17TestCaseOperation1Request(input *InputService17TestShapeInputService17TestCaseOperation2Input) (req *request.Request, output *InputService17TestShapeInputService17TestCaseOperation1Output) { 2908 op := &request.Operation{ 2909 Name: opInputService17TestCaseOperation1, 2910 HTTPMethod: "POST", 2911 HTTPPath: "/", 2912 } 2913 2914 if input == nil { 2915 input = &InputService17TestShapeInputService17TestCaseOperation2Input{} 2916 } 2917 2918 output = &InputService17TestShapeInputService17TestCaseOperation1Output{} 2919 req = c.newRequest(op, input, output) 2920 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 2921 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2922 return 2923} 2924 2925// InputService17TestCaseOperation1 API operation for . 2926// 2927// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2928// with awserr.Error's Code and Message methods to get detailed information about 2929// the error. 2930// 2931// See the AWS API reference guide for 's 2932// API operation InputService17TestCaseOperation1 for usage and error information. 2933func (c *InputService17ProtocolTest) InputService17TestCaseOperation1(input *InputService17TestShapeInputService17TestCaseOperation2Input) (*InputService17TestShapeInputService17TestCaseOperation1Output, error) { 2934 req, out := c.InputService17TestCaseOperation1Request(input) 2935 return out, req.Send() 2936} 2937 2938// InputService17TestCaseOperation1WithContext is the same as InputService17TestCaseOperation1 with the addition of 2939// the ability to pass a context and additional request options. 2940// 2941// See InputService17TestCaseOperation1 for details on how to use this API operation. 2942// 2943// The context must be non-nil and will be used for request cancellation. If 2944// the context is nil a panic will occur. In the future the SDK may create 2945// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2946// for more information on using Contexts. 2947func (c *InputService17ProtocolTest) InputService17TestCaseOperation1WithContext(ctx aws.Context, input *InputService17TestShapeInputService17TestCaseOperation2Input, opts ...request.Option) (*InputService17TestShapeInputService17TestCaseOperation1Output, error) { 2948 req, out := c.InputService17TestCaseOperation1Request(input) 2949 req.SetContext(ctx) 2950 req.ApplyOptions(opts...) 2951 return out, req.Send() 2952} 2953 2954const opInputService17TestCaseOperation2 = "OperationName" 2955 2956// InputService17TestCaseOperation2Request generates a "aws/request.Request" representing the 2957// client's request for the InputService17TestCaseOperation2 operation. The "output" return 2958// value will be populated with the request's response once the request complets 2959// successfuly. 2960// 2961// Use "Send" method on the returned Request to send the API call to the service. 2962// the "output" return value is not valid until after Send returns without error. 2963// 2964// See InputService17TestCaseOperation2 for more information on using the InputService17TestCaseOperation2 2965// API call, and error handling. 2966// 2967// This method is useful when you want to inject custom logic or configuration 2968// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2969// 2970// 2971// // Example sending a request using the InputService17TestCaseOperation2Request method. 2972// req, resp := client.InputService17TestCaseOperation2Request(params) 2973// 2974// err := req.Send() 2975// if err == nil { // resp is now filled 2976// fmt.Println(resp) 2977// } 2978func (c *InputService17ProtocolTest) InputService17TestCaseOperation2Request(input *InputService17TestShapeInputService17TestCaseOperation2Input) (req *request.Request, output *InputService17TestShapeInputService17TestCaseOperation2Output) { 2979 op := &request.Operation{ 2980 Name: opInputService17TestCaseOperation2, 2981 HTTPMethod: "POST", 2982 HTTPPath: "/", 2983 } 2984 2985 if input == nil { 2986 input = &InputService17TestShapeInputService17TestCaseOperation2Input{} 2987 } 2988 2989 output = &InputService17TestShapeInputService17TestCaseOperation2Output{} 2990 req = c.newRequest(op, input, output) 2991 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 2992 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2993 return 2994} 2995 2996// InputService17TestCaseOperation2 API operation for . 2997// 2998// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2999// with awserr.Error's Code and Message methods to get detailed information about 3000// the error. 3001// 3002// See the AWS API reference guide for 's 3003// API operation InputService17TestCaseOperation2 for usage and error information. 3004func (c *InputService17ProtocolTest) InputService17TestCaseOperation2(input *InputService17TestShapeInputService17TestCaseOperation2Input) (*InputService17TestShapeInputService17TestCaseOperation2Output, error) { 3005 req, out := c.InputService17TestCaseOperation2Request(input) 3006 return out, req.Send() 3007} 3008 3009// InputService17TestCaseOperation2WithContext is the same as InputService17TestCaseOperation2 with the addition of 3010// the ability to pass a context and additional request options. 3011// 3012// See InputService17TestCaseOperation2 for details on how to use this API operation. 3013// 3014// The context must be non-nil and will be used for request cancellation. If 3015// the context is nil a panic will occur. In the future the SDK may create 3016// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3017// for more information on using Contexts. 3018func (c *InputService17ProtocolTest) InputService17TestCaseOperation2WithContext(ctx aws.Context, input *InputService17TestShapeInputService17TestCaseOperation2Input, opts ...request.Option) (*InputService17TestShapeInputService17TestCaseOperation2Output, error) { 3019 req, out := c.InputService17TestCaseOperation2Request(input) 3020 req.SetContext(ctx) 3021 req.ApplyOptions(opts...) 3022 return out, req.Send() 3023} 3024 3025type InputService17TestShapeInputService17TestCaseOperation1Output struct { 3026 _ struct{} `type:"structure"` 3027} 3028 3029type InputService17TestShapeInputService17TestCaseOperation2Input struct { 3030 _ struct{} `type:"structure" payload:"Foo"` 3031 3032 Foo []byte `locationName:"foo" type:"blob"` 3033} 3034 3035// SetFoo sets the Foo field's value. 3036func (s *InputService17TestShapeInputService17TestCaseOperation2Input) SetFoo(v []byte) *InputService17TestShapeInputService17TestCaseOperation2Input { 3037 s.Foo = v 3038 return s 3039} 3040 3041type InputService17TestShapeInputService17TestCaseOperation2Output struct { 3042 _ struct{} `type:"structure"` 3043} 3044 3045// InputService18ProtocolTest provides the API operation methods for making requests to 3046// . See this package's package overview docs 3047// for details on the service. 3048// 3049// InputService18ProtocolTest methods are safe to use concurrently. It is not safe to 3050// modify mutate any of the struct's properties though. 3051type InputService18ProtocolTest struct { 3052 *client.Client 3053} 3054 3055// New creates a new instance of the InputService18ProtocolTest client with a session. 3056// If additional configuration is needed for the client instance use the optional 3057// aws.Config parameter to add your extra config. 3058// 3059// Example: 3060// // Create a InputService18ProtocolTest client from just a session. 3061// svc := inputservice18protocoltest.New(mySession) 3062// 3063// // Create a InputService18ProtocolTest client with additional configuration 3064// svc := inputservice18protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 3065func NewInputService18ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService18ProtocolTest { 3066 c := p.ClientConfig("inputservice18protocoltest", cfgs...) 3067 return newInputService18ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 3068} 3069 3070// newClient creates, initializes and returns a new service client instance. 3071func newInputService18ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService18ProtocolTest { 3072 svc := &InputService18ProtocolTest{ 3073 Client: client.New( 3074 cfg, 3075 metadata.ClientInfo{ 3076 ServiceName: "inputservice18protocoltest", 3077 SigningName: signingName, 3078 SigningRegion: signingRegion, 3079 Endpoint: endpoint, 3080 APIVersion: "2014-01-01", 3081 }, 3082 handlers, 3083 ), 3084 } 3085 3086 // Handlers 3087 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 3088 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 3089 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 3090 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 3091 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 3092 3093 return svc 3094} 3095 3096// newRequest creates a new request for a InputService18ProtocolTest operation and runs any 3097// custom request initialization. 3098func (c *InputService18ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 3099 req := c.NewRequest(op, params, data) 3100 3101 return req 3102} 3103 3104const opInputService18TestCaseOperation1 = "OperationName" 3105 3106// InputService18TestCaseOperation1Request generates a "aws/request.Request" representing the 3107// client's request for the InputService18TestCaseOperation1 operation. The "output" return 3108// value will be populated with the request's response once the request complets 3109// successfuly. 3110// 3111// Use "Send" method on the returned Request to send the API call to the service. 3112// the "output" return value is not valid until after Send returns without error. 3113// 3114// See InputService18TestCaseOperation1 for more information on using the InputService18TestCaseOperation1 3115// API call, and error handling. 3116// 3117// This method is useful when you want to inject custom logic or configuration 3118// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3119// 3120// 3121// // Example sending a request using the InputService18TestCaseOperation1Request method. 3122// req, resp := client.InputService18TestCaseOperation1Request(params) 3123// 3124// err := req.Send() 3125// if err == nil { // resp is now filled 3126// fmt.Println(resp) 3127// } 3128func (c *InputService18ProtocolTest) InputService18TestCaseOperation1Request(input *InputService18TestShapeInputService18TestCaseOperation4Input) (req *request.Request, output *InputService18TestShapeInputService18TestCaseOperation1Output) { 3129 op := &request.Operation{ 3130 Name: opInputService18TestCaseOperation1, 3131 HTTPMethod: "POST", 3132 HTTPPath: "/", 3133 } 3134 3135 if input == nil { 3136 input = &InputService18TestShapeInputService18TestCaseOperation4Input{} 3137 } 3138 3139 output = &InputService18TestShapeInputService18TestCaseOperation1Output{} 3140 req = c.newRequest(op, input, output) 3141 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 3142 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 3143 return 3144} 3145 3146// InputService18TestCaseOperation1 API operation for . 3147// 3148// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3149// with awserr.Error's Code and Message methods to get detailed information about 3150// the error. 3151// 3152// See the AWS API reference guide for 's 3153// API operation InputService18TestCaseOperation1 for usage and error information. 3154func (c *InputService18ProtocolTest) InputService18TestCaseOperation1(input *InputService18TestShapeInputService18TestCaseOperation4Input) (*InputService18TestShapeInputService18TestCaseOperation1Output, error) { 3155 req, out := c.InputService18TestCaseOperation1Request(input) 3156 return out, req.Send() 3157} 3158 3159// InputService18TestCaseOperation1WithContext is the same as InputService18TestCaseOperation1 with the addition of 3160// the ability to pass a context and additional request options. 3161// 3162// See InputService18TestCaseOperation1 for details on how to use this API operation. 3163// 3164// The context must be non-nil and will be used for request cancellation. If 3165// the context is nil a panic will occur. In the future the SDK may create 3166// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3167// for more information on using Contexts. 3168func (c *InputService18ProtocolTest) InputService18TestCaseOperation1WithContext(ctx aws.Context, input *InputService18TestShapeInputService18TestCaseOperation4Input, opts ...request.Option) (*InputService18TestShapeInputService18TestCaseOperation1Output, error) { 3169 req, out := c.InputService18TestCaseOperation1Request(input) 3170 req.SetContext(ctx) 3171 req.ApplyOptions(opts...) 3172 return out, req.Send() 3173} 3174 3175const opInputService18TestCaseOperation2 = "OperationName" 3176 3177// InputService18TestCaseOperation2Request generates a "aws/request.Request" representing the 3178// client's request for the InputService18TestCaseOperation2 operation. The "output" return 3179// value will be populated with the request's response once the request complets 3180// successfuly. 3181// 3182// Use "Send" method on the returned Request to send the API call to the service. 3183// the "output" return value is not valid until after Send returns without error. 3184// 3185// See InputService18TestCaseOperation2 for more information on using the InputService18TestCaseOperation2 3186// API call, and error handling. 3187// 3188// This method is useful when you want to inject custom logic or configuration 3189// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3190// 3191// 3192// // Example sending a request using the InputService18TestCaseOperation2Request method. 3193// req, resp := client.InputService18TestCaseOperation2Request(params) 3194// 3195// err := req.Send() 3196// if err == nil { // resp is now filled 3197// fmt.Println(resp) 3198// } 3199func (c *InputService18ProtocolTest) InputService18TestCaseOperation2Request(input *InputService18TestShapeInputService18TestCaseOperation4Input) (req *request.Request, output *InputService18TestShapeInputService18TestCaseOperation2Output) { 3200 op := &request.Operation{ 3201 Name: opInputService18TestCaseOperation2, 3202 HTTPMethod: "POST", 3203 HTTPPath: "/", 3204 } 3205 3206 if input == nil { 3207 input = &InputService18TestShapeInputService18TestCaseOperation4Input{} 3208 } 3209 3210 output = &InputService18TestShapeInputService18TestCaseOperation2Output{} 3211 req = c.newRequest(op, input, output) 3212 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 3213 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 3214 return 3215} 3216 3217// InputService18TestCaseOperation2 API operation for . 3218// 3219// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3220// with awserr.Error's Code and Message methods to get detailed information about 3221// the error. 3222// 3223// See the AWS API reference guide for 's 3224// API operation InputService18TestCaseOperation2 for usage and error information. 3225func (c *InputService18ProtocolTest) InputService18TestCaseOperation2(input *InputService18TestShapeInputService18TestCaseOperation4Input) (*InputService18TestShapeInputService18TestCaseOperation2Output, error) { 3226 req, out := c.InputService18TestCaseOperation2Request(input) 3227 return out, req.Send() 3228} 3229 3230// InputService18TestCaseOperation2WithContext is the same as InputService18TestCaseOperation2 with the addition of 3231// the ability to pass a context and additional request options. 3232// 3233// See InputService18TestCaseOperation2 for details on how to use this API operation. 3234// 3235// The context must be non-nil and will be used for request cancellation. If 3236// the context is nil a panic will occur. In the future the SDK may create 3237// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3238// for more information on using Contexts. 3239func (c *InputService18ProtocolTest) InputService18TestCaseOperation2WithContext(ctx aws.Context, input *InputService18TestShapeInputService18TestCaseOperation4Input, opts ...request.Option) (*InputService18TestShapeInputService18TestCaseOperation2Output, error) { 3240 req, out := c.InputService18TestCaseOperation2Request(input) 3241 req.SetContext(ctx) 3242 req.ApplyOptions(opts...) 3243 return out, req.Send() 3244} 3245 3246const opInputService18TestCaseOperation3 = "OperationName" 3247 3248// InputService18TestCaseOperation3Request generates a "aws/request.Request" representing the 3249// client's request for the InputService18TestCaseOperation3 operation. The "output" return 3250// value will be populated with the request's response once the request complets 3251// successfuly. 3252// 3253// Use "Send" method on the returned Request to send the API call to the service. 3254// the "output" return value is not valid until after Send returns without error. 3255// 3256// See InputService18TestCaseOperation3 for more information on using the InputService18TestCaseOperation3 3257// API call, and error handling. 3258// 3259// This method is useful when you want to inject custom logic or configuration 3260// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3261// 3262// 3263// // Example sending a request using the InputService18TestCaseOperation3Request method. 3264// req, resp := client.InputService18TestCaseOperation3Request(params) 3265// 3266// err := req.Send() 3267// if err == nil { // resp is now filled 3268// fmt.Println(resp) 3269// } 3270func (c *InputService18ProtocolTest) InputService18TestCaseOperation3Request(input *InputService18TestShapeInputService18TestCaseOperation4Input) (req *request.Request, output *InputService18TestShapeInputService18TestCaseOperation3Output) { 3271 op := &request.Operation{ 3272 Name: opInputService18TestCaseOperation3, 3273 HTTPMethod: "POST", 3274 HTTPPath: "/", 3275 } 3276 3277 if input == nil { 3278 input = &InputService18TestShapeInputService18TestCaseOperation4Input{} 3279 } 3280 3281 output = &InputService18TestShapeInputService18TestCaseOperation3Output{} 3282 req = c.newRequest(op, input, output) 3283 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 3284 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 3285 return 3286} 3287 3288// InputService18TestCaseOperation3 API operation for . 3289// 3290// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3291// with awserr.Error's Code and Message methods to get detailed information about 3292// the error. 3293// 3294// See the AWS API reference guide for 's 3295// API operation InputService18TestCaseOperation3 for usage and error information. 3296func (c *InputService18ProtocolTest) InputService18TestCaseOperation3(input *InputService18TestShapeInputService18TestCaseOperation4Input) (*InputService18TestShapeInputService18TestCaseOperation3Output, error) { 3297 req, out := c.InputService18TestCaseOperation3Request(input) 3298 return out, req.Send() 3299} 3300 3301// InputService18TestCaseOperation3WithContext is the same as InputService18TestCaseOperation3 with the addition of 3302// the ability to pass a context and additional request options. 3303// 3304// See InputService18TestCaseOperation3 for details on how to use this API operation. 3305// 3306// The context must be non-nil and will be used for request cancellation. If 3307// the context is nil a panic will occur. In the future the SDK may create 3308// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3309// for more information on using Contexts. 3310func (c *InputService18ProtocolTest) InputService18TestCaseOperation3WithContext(ctx aws.Context, input *InputService18TestShapeInputService18TestCaseOperation4Input, opts ...request.Option) (*InputService18TestShapeInputService18TestCaseOperation3Output, error) { 3311 req, out := c.InputService18TestCaseOperation3Request(input) 3312 req.SetContext(ctx) 3313 req.ApplyOptions(opts...) 3314 return out, req.Send() 3315} 3316 3317const opInputService18TestCaseOperation4 = "OperationName" 3318 3319// InputService18TestCaseOperation4Request generates a "aws/request.Request" representing the 3320// client's request for the InputService18TestCaseOperation4 operation. The "output" return 3321// value will be populated with the request's response once the request complets 3322// successfuly. 3323// 3324// Use "Send" method on the returned Request to send the API call to the service. 3325// the "output" return value is not valid until after Send returns without error. 3326// 3327// See InputService18TestCaseOperation4 for more information on using the InputService18TestCaseOperation4 3328// API call, and error handling. 3329// 3330// This method is useful when you want to inject custom logic or configuration 3331// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3332// 3333// 3334// // Example sending a request using the InputService18TestCaseOperation4Request method. 3335// req, resp := client.InputService18TestCaseOperation4Request(params) 3336// 3337// err := req.Send() 3338// if err == nil { // resp is now filled 3339// fmt.Println(resp) 3340// } 3341func (c *InputService18ProtocolTest) InputService18TestCaseOperation4Request(input *InputService18TestShapeInputService18TestCaseOperation4Input) (req *request.Request, output *InputService18TestShapeInputService18TestCaseOperation4Output) { 3342 op := &request.Operation{ 3343 Name: opInputService18TestCaseOperation4, 3344 HTTPMethod: "POST", 3345 HTTPPath: "/", 3346 } 3347 3348 if input == nil { 3349 input = &InputService18TestShapeInputService18TestCaseOperation4Input{} 3350 } 3351 3352 output = &InputService18TestShapeInputService18TestCaseOperation4Output{} 3353 req = c.newRequest(op, input, output) 3354 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 3355 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 3356 return 3357} 3358 3359// InputService18TestCaseOperation4 API operation for . 3360// 3361// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3362// with awserr.Error's Code and Message methods to get detailed information about 3363// the error. 3364// 3365// See the AWS API reference guide for 's 3366// API operation InputService18TestCaseOperation4 for usage and error information. 3367func (c *InputService18ProtocolTest) InputService18TestCaseOperation4(input *InputService18TestShapeInputService18TestCaseOperation4Input) (*InputService18TestShapeInputService18TestCaseOperation4Output, error) { 3368 req, out := c.InputService18TestCaseOperation4Request(input) 3369 return out, req.Send() 3370} 3371 3372// InputService18TestCaseOperation4WithContext is the same as InputService18TestCaseOperation4 with the addition of 3373// the ability to pass a context and additional request options. 3374// 3375// See InputService18TestCaseOperation4 for details on how to use this API operation. 3376// 3377// The context must be non-nil and will be used for request cancellation. If 3378// the context is nil a panic will occur. In the future the SDK may create 3379// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3380// for more information on using Contexts. 3381func (c *InputService18ProtocolTest) InputService18TestCaseOperation4WithContext(ctx aws.Context, input *InputService18TestShapeInputService18TestCaseOperation4Input, opts ...request.Option) (*InputService18TestShapeInputService18TestCaseOperation4Output, error) { 3382 req, out := c.InputService18TestCaseOperation4Request(input) 3383 req.SetContext(ctx) 3384 req.ApplyOptions(opts...) 3385 return out, req.Send() 3386} 3387 3388type InputService18TestShapeFooShape struct { 3389 _ struct{} `locationName:"foo" type:"structure"` 3390 3391 Baz *string `locationName:"baz" type:"string"` 3392} 3393 3394// SetBaz sets the Baz field's value. 3395func (s *InputService18TestShapeFooShape) SetBaz(v string) *InputService18TestShapeFooShape { 3396 s.Baz = &v 3397 return s 3398} 3399 3400type InputService18TestShapeInputService18TestCaseOperation1Output struct { 3401 _ struct{} `type:"structure"` 3402} 3403 3404type InputService18TestShapeInputService18TestCaseOperation2Output struct { 3405 _ struct{} `type:"structure"` 3406} 3407 3408type InputService18TestShapeInputService18TestCaseOperation3Output struct { 3409 _ struct{} `type:"structure"` 3410} 3411 3412type InputService18TestShapeInputService18TestCaseOperation4Input struct { 3413 _ struct{} `type:"structure" payload:"Foo"` 3414 3415 Foo *InputService18TestShapeFooShape `locationName:"foo" type:"structure"` 3416} 3417 3418// SetFoo sets the Foo field's value. 3419func (s *InputService18TestShapeInputService18TestCaseOperation4Input) SetFoo(v *InputService18TestShapeFooShape) *InputService18TestShapeInputService18TestCaseOperation4Input { 3420 s.Foo = v 3421 return s 3422} 3423 3424type InputService18TestShapeInputService18TestCaseOperation4Output struct { 3425 _ struct{} `type:"structure"` 3426} 3427 3428// InputService19ProtocolTest provides the API operation methods for making requests to 3429// . See this package's package overview docs 3430// for details on the service. 3431// 3432// InputService19ProtocolTest methods are safe to use concurrently. It is not safe to 3433// modify mutate any of the struct's properties though. 3434type InputService19ProtocolTest struct { 3435 *client.Client 3436} 3437 3438// New creates a new instance of the InputService19ProtocolTest client with a session. 3439// If additional configuration is needed for the client instance use the optional 3440// aws.Config parameter to add your extra config. 3441// 3442// Example: 3443// // Create a InputService19ProtocolTest client from just a session. 3444// svc := inputservice19protocoltest.New(mySession) 3445// 3446// // Create a InputService19ProtocolTest client with additional configuration 3447// svc := inputservice19protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 3448func NewInputService19ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService19ProtocolTest { 3449 c := p.ClientConfig("inputservice19protocoltest", cfgs...) 3450 return newInputService19ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 3451} 3452 3453// newClient creates, initializes and returns a new service client instance. 3454func newInputService19ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService19ProtocolTest { 3455 svc := &InputService19ProtocolTest{ 3456 Client: client.New( 3457 cfg, 3458 metadata.ClientInfo{ 3459 ServiceName: "inputservice19protocoltest", 3460 SigningName: signingName, 3461 SigningRegion: signingRegion, 3462 Endpoint: endpoint, 3463 APIVersion: "2014-01-01", 3464 }, 3465 handlers, 3466 ), 3467 } 3468 3469 // Handlers 3470 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 3471 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 3472 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 3473 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 3474 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 3475 3476 return svc 3477} 3478 3479// newRequest creates a new request for a InputService19ProtocolTest operation and runs any 3480// custom request initialization. 3481func (c *InputService19ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 3482 req := c.NewRequest(op, params, data) 3483 3484 return req 3485} 3486 3487const opInputService19TestCaseOperation1 = "OperationName" 3488 3489// InputService19TestCaseOperation1Request generates a "aws/request.Request" representing the 3490// client's request for the InputService19TestCaseOperation1 operation. The "output" return 3491// value will be populated with the request's response once the request complets 3492// successfuly. 3493// 3494// Use "Send" method on the returned Request to send the API call to the service. 3495// the "output" return value is not valid until after Send returns without error. 3496// 3497// See InputService19TestCaseOperation1 for more information on using the InputService19TestCaseOperation1 3498// API call, and error handling. 3499// 3500// This method is useful when you want to inject custom logic or configuration 3501// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3502// 3503// 3504// // Example sending a request using the InputService19TestCaseOperation1Request method. 3505// req, resp := client.InputService19TestCaseOperation1Request(params) 3506// 3507// err := req.Send() 3508// if err == nil { // resp is now filled 3509// fmt.Println(resp) 3510// } 3511func (c *InputService19ProtocolTest) InputService19TestCaseOperation1Request(input *InputService19TestShapeInputService19TestCaseOperation1Input) (req *request.Request, output *InputService19TestShapeInputService19TestCaseOperation1Output) { 3512 op := &request.Operation{ 3513 Name: opInputService19TestCaseOperation1, 3514 HTTPMethod: "POST", 3515 HTTPPath: "/", 3516 } 3517 3518 if input == nil { 3519 input = &InputService19TestShapeInputService19TestCaseOperation1Input{} 3520 } 3521 3522 output = &InputService19TestShapeInputService19TestCaseOperation1Output{} 3523 req = c.newRequest(op, input, output) 3524 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 3525 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 3526 return 3527} 3528 3529// InputService19TestCaseOperation1 API operation for . 3530// 3531// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3532// with awserr.Error's Code and Message methods to get detailed information about 3533// the error. 3534// 3535// See the AWS API reference guide for 's 3536// API operation InputService19TestCaseOperation1 for usage and error information. 3537func (c *InputService19ProtocolTest) InputService19TestCaseOperation1(input *InputService19TestShapeInputService19TestCaseOperation1Input) (*InputService19TestShapeInputService19TestCaseOperation1Output, error) { 3538 req, out := c.InputService19TestCaseOperation1Request(input) 3539 return out, req.Send() 3540} 3541 3542// InputService19TestCaseOperation1WithContext is the same as InputService19TestCaseOperation1 with the addition of 3543// the ability to pass a context and additional request options. 3544// 3545// See InputService19TestCaseOperation1 for details on how to use this API operation. 3546// 3547// The context must be non-nil and will be used for request cancellation. If 3548// the context is nil a panic will occur. In the future the SDK may create 3549// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3550// for more information on using Contexts. 3551func (c *InputService19ProtocolTest) InputService19TestCaseOperation1WithContext(ctx aws.Context, input *InputService19TestShapeInputService19TestCaseOperation1Input, opts ...request.Option) (*InputService19TestShapeInputService19TestCaseOperation1Output, error) { 3552 req, out := c.InputService19TestCaseOperation1Request(input) 3553 req.SetContext(ctx) 3554 req.ApplyOptions(opts...) 3555 return out, req.Send() 3556} 3557 3558type InputService19TestShapeGrant struct { 3559 _ struct{} `locationName:"Grant" type:"structure"` 3560 3561 Grantee *InputService19TestShapeGrantee `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"` 3562} 3563 3564// SetGrantee sets the Grantee field's value. 3565func (s *InputService19TestShapeGrant) SetGrantee(v *InputService19TestShapeGrantee) *InputService19TestShapeGrant { 3566 s.Grantee = v 3567 return s 3568} 3569 3570type InputService19TestShapeGrantee struct { 3571 _ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"` 3572 3573 EmailAddress *string `type:"string"` 3574 3575 Type *string `locationName:"xsi:type" type:"string" xmlAttribute:"true"` 3576} 3577 3578// SetEmailAddress sets the EmailAddress field's value. 3579func (s *InputService19TestShapeGrantee) SetEmailAddress(v string) *InputService19TestShapeGrantee { 3580 s.EmailAddress = &v 3581 return s 3582} 3583 3584// SetType sets the Type field's value. 3585func (s *InputService19TestShapeGrantee) SetType(v string) *InputService19TestShapeGrantee { 3586 s.Type = &v 3587 return s 3588} 3589 3590type InputService19TestShapeInputService19TestCaseOperation1Input struct { 3591 _ struct{} `type:"structure" payload:"Grant"` 3592 3593 Grant *InputService19TestShapeGrant `locationName:"Grant" type:"structure"` 3594} 3595 3596// SetGrant sets the Grant field's value. 3597func (s *InputService19TestShapeInputService19TestCaseOperation1Input) SetGrant(v *InputService19TestShapeGrant) *InputService19TestShapeInputService19TestCaseOperation1Input { 3598 s.Grant = v 3599 return s 3600} 3601 3602type InputService19TestShapeInputService19TestCaseOperation1Output struct { 3603 _ struct{} `type:"structure"` 3604} 3605 3606// InputService20ProtocolTest provides the API operation methods for making requests to 3607// . See this package's package overview docs 3608// for details on the service. 3609// 3610// InputService20ProtocolTest methods are safe to use concurrently. It is not safe to 3611// modify mutate any of the struct's properties though. 3612type InputService20ProtocolTest struct { 3613 *client.Client 3614} 3615 3616// New creates a new instance of the InputService20ProtocolTest client with a session. 3617// If additional configuration is needed for the client instance use the optional 3618// aws.Config parameter to add your extra config. 3619// 3620// Example: 3621// // Create a InputService20ProtocolTest client from just a session. 3622// svc := inputservice20protocoltest.New(mySession) 3623// 3624// // Create a InputService20ProtocolTest client with additional configuration 3625// svc := inputservice20protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 3626func NewInputService20ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService20ProtocolTest { 3627 c := p.ClientConfig("inputservice20protocoltest", cfgs...) 3628 return newInputService20ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 3629} 3630 3631// newClient creates, initializes and returns a new service client instance. 3632func newInputService20ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService20ProtocolTest { 3633 svc := &InputService20ProtocolTest{ 3634 Client: client.New( 3635 cfg, 3636 metadata.ClientInfo{ 3637 ServiceName: "inputservice20protocoltest", 3638 SigningName: signingName, 3639 SigningRegion: signingRegion, 3640 Endpoint: endpoint, 3641 APIVersion: "2014-01-01", 3642 }, 3643 handlers, 3644 ), 3645 } 3646 3647 // Handlers 3648 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 3649 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 3650 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 3651 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 3652 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 3653 3654 return svc 3655} 3656 3657// newRequest creates a new request for a InputService20ProtocolTest operation and runs any 3658// custom request initialization. 3659func (c *InputService20ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 3660 req := c.NewRequest(op, params, data) 3661 3662 return req 3663} 3664 3665const opInputService20TestCaseOperation1 = "OperationName" 3666 3667// InputService20TestCaseOperation1Request generates a "aws/request.Request" representing the 3668// client's request for the InputService20TestCaseOperation1 operation. The "output" return 3669// value will be populated with the request's response once the request complets 3670// successfuly. 3671// 3672// Use "Send" method on the returned Request to send the API call to the service. 3673// the "output" return value is not valid until after Send returns without error. 3674// 3675// See InputService20TestCaseOperation1 for more information on using the InputService20TestCaseOperation1 3676// API call, and error handling. 3677// 3678// This method is useful when you want to inject custom logic or configuration 3679// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3680// 3681// 3682// // Example sending a request using the InputService20TestCaseOperation1Request method. 3683// req, resp := client.InputService20TestCaseOperation1Request(params) 3684// 3685// err := req.Send() 3686// if err == nil { // resp is now filled 3687// fmt.Println(resp) 3688// } 3689func (c *InputService20ProtocolTest) InputService20TestCaseOperation1Request(input *InputService20TestShapeInputService20TestCaseOperation1Input) (req *request.Request, output *InputService20TestShapeInputService20TestCaseOperation1Output) { 3690 op := &request.Operation{ 3691 Name: opInputService20TestCaseOperation1, 3692 HTTPMethod: "GET", 3693 HTTPPath: "/{Bucket}/{Key+}", 3694 } 3695 3696 if input == nil { 3697 input = &InputService20TestShapeInputService20TestCaseOperation1Input{} 3698 } 3699 3700 output = &InputService20TestShapeInputService20TestCaseOperation1Output{} 3701 req = c.newRequest(op, input, output) 3702 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 3703 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 3704 return 3705} 3706 3707// InputService20TestCaseOperation1 API operation for . 3708// 3709// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3710// with awserr.Error's Code and Message methods to get detailed information about 3711// the error. 3712// 3713// See the AWS API reference guide for 's 3714// API operation InputService20TestCaseOperation1 for usage and error information. 3715func (c *InputService20ProtocolTest) InputService20TestCaseOperation1(input *InputService20TestShapeInputService20TestCaseOperation1Input) (*InputService20TestShapeInputService20TestCaseOperation1Output, error) { 3716 req, out := c.InputService20TestCaseOperation1Request(input) 3717 return out, req.Send() 3718} 3719 3720// InputService20TestCaseOperation1WithContext is the same as InputService20TestCaseOperation1 with the addition of 3721// the ability to pass a context and additional request options. 3722// 3723// See InputService20TestCaseOperation1 for details on how to use this API operation. 3724// 3725// The context must be non-nil and will be used for request cancellation. If 3726// the context is nil a panic will occur. In the future the SDK may create 3727// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3728// for more information on using Contexts. 3729func (c *InputService20ProtocolTest) InputService20TestCaseOperation1WithContext(ctx aws.Context, input *InputService20TestShapeInputService20TestCaseOperation1Input, opts ...request.Option) (*InputService20TestShapeInputService20TestCaseOperation1Output, error) { 3730 req, out := c.InputService20TestCaseOperation1Request(input) 3731 req.SetContext(ctx) 3732 req.ApplyOptions(opts...) 3733 return out, req.Send() 3734} 3735 3736type InputService20TestShapeInputService20TestCaseOperation1Input struct { 3737 _ struct{} `type:"structure"` 3738 3739 Bucket *string `location:"uri" type:"string"` 3740 3741 Key *string `location:"uri" type:"string"` 3742} 3743 3744// SetBucket sets the Bucket field's value. 3745func (s *InputService20TestShapeInputService20TestCaseOperation1Input) SetBucket(v string) *InputService20TestShapeInputService20TestCaseOperation1Input { 3746 s.Bucket = &v 3747 return s 3748} 3749 3750// SetKey sets the Key field's value. 3751func (s *InputService20TestShapeInputService20TestCaseOperation1Input) SetKey(v string) *InputService20TestShapeInputService20TestCaseOperation1Input { 3752 s.Key = &v 3753 return s 3754} 3755 3756type InputService20TestShapeInputService20TestCaseOperation1Output struct { 3757 _ struct{} `type:"structure"` 3758} 3759 3760// InputService21ProtocolTest provides the API operation methods for making requests to 3761// . See this package's package overview docs 3762// for details on the service. 3763// 3764// InputService21ProtocolTest methods are safe to use concurrently. It is not safe to 3765// modify mutate any of the struct's properties though. 3766type InputService21ProtocolTest struct { 3767 *client.Client 3768} 3769 3770// New creates a new instance of the InputService21ProtocolTest client with a session. 3771// If additional configuration is needed for the client instance use the optional 3772// aws.Config parameter to add your extra config. 3773// 3774// Example: 3775// // Create a InputService21ProtocolTest client from just a session. 3776// svc := inputservice21protocoltest.New(mySession) 3777// 3778// // Create a InputService21ProtocolTest client with additional configuration 3779// svc := inputservice21protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 3780func NewInputService21ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService21ProtocolTest { 3781 c := p.ClientConfig("inputservice21protocoltest", cfgs...) 3782 return newInputService21ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 3783} 3784 3785// newClient creates, initializes and returns a new service client instance. 3786func newInputService21ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService21ProtocolTest { 3787 svc := &InputService21ProtocolTest{ 3788 Client: client.New( 3789 cfg, 3790 metadata.ClientInfo{ 3791 ServiceName: "inputservice21protocoltest", 3792 SigningName: signingName, 3793 SigningRegion: signingRegion, 3794 Endpoint: endpoint, 3795 APIVersion: "2014-01-01", 3796 }, 3797 handlers, 3798 ), 3799 } 3800 3801 // Handlers 3802 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 3803 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 3804 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 3805 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 3806 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 3807 3808 return svc 3809} 3810 3811// newRequest creates a new request for a InputService21ProtocolTest operation and runs any 3812// custom request initialization. 3813func (c *InputService21ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 3814 req := c.NewRequest(op, params, data) 3815 3816 return req 3817} 3818 3819const opInputService21TestCaseOperation1 = "OperationName" 3820 3821// InputService21TestCaseOperation1Request generates a "aws/request.Request" representing the 3822// client's request for the InputService21TestCaseOperation1 operation. The "output" return 3823// value will be populated with the request's response once the request complets 3824// successfuly. 3825// 3826// Use "Send" method on the returned Request to send the API call to the service. 3827// the "output" return value is not valid until after Send returns without error. 3828// 3829// See InputService21TestCaseOperation1 for more information on using the InputService21TestCaseOperation1 3830// API call, and error handling. 3831// 3832// This method is useful when you want to inject custom logic or configuration 3833// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3834// 3835// 3836// // Example sending a request using the InputService21TestCaseOperation1Request method. 3837// req, resp := client.InputService21TestCaseOperation1Request(params) 3838// 3839// err := req.Send() 3840// if err == nil { // resp is now filled 3841// fmt.Println(resp) 3842// } 3843func (c *InputService21ProtocolTest) InputService21TestCaseOperation1Request(input *InputService21TestShapeInputService21TestCaseOperation2Input) (req *request.Request, output *InputService21TestShapeInputService21TestCaseOperation1Output) { 3844 op := &request.Operation{ 3845 Name: opInputService21TestCaseOperation1, 3846 HTTPMethod: "POST", 3847 HTTPPath: "/path", 3848 } 3849 3850 if input == nil { 3851 input = &InputService21TestShapeInputService21TestCaseOperation2Input{} 3852 } 3853 3854 output = &InputService21TestShapeInputService21TestCaseOperation1Output{} 3855 req = c.newRequest(op, input, output) 3856 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 3857 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 3858 return 3859} 3860 3861// InputService21TestCaseOperation1 API operation for . 3862// 3863// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3864// with awserr.Error's Code and Message methods to get detailed information about 3865// the error. 3866// 3867// See the AWS API reference guide for 's 3868// API operation InputService21TestCaseOperation1 for usage and error information. 3869func (c *InputService21ProtocolTest) InputService21TestCaseOperation1(input *InputService21TestShapeInputService21TestCaseOperation2Input) (*InputService21TestShapeInputService21TestCaseOperation1Output, error) { 3870 req, out := c.InputService21TestCaseOperation1Request(input) 3871 return out, req.Send() 3872} 3873 3874// InputService21TestCaseOperation1WithContext is the same as InputService21TestCaseOperation1 with the addition of 3875// the ability to pass a context and additional request options. 3876// 3877// See InputService21TestCaseOperation1 for details on how to use this API operation. 3878// 3879// The context must be non-nil and will be used for request cancellation. If 3880// the context is nil a panic will occur. In the future the SDK may create 3881// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3882// for more information on using Contexts. 3883func (c *InputService21ProtocolTest) InputService21TestCaseOperation1WithContext(ctx aws.Context, input *InputService21TestShapeInputService21TestCaseOperation2Input, opts ...request.Option) (*InputService21TestShapeInputService21TestCaseOperation1Output, error) { 3884 req, out := c.InputService21TestCaseOperation1Request(input) 3885 req.SetContext(ctx) 3886 req.ApplyOptions(opts...) 3887 return out, req.Send() 3888} 3889 3890const opInputService21TestCaseOperation2 = "OperationName" 3891 3892// InputService21TestCaseOperation2Request generates a "aws/request.Request" representing the 3893// client's request for the InputService21TestCaseOperation2 operation. The "output" return 3894// value will be populated with the request's response once the request complets 3895// successfuly. 3896// 3897// Use "Send" method on the returned Request to send the API call to the service. 3898// the "output" return value is not valid until after Send returns without error. 3899// 3900// See InputService21TestCaseOperation2 for more information on using the InputService21TestCaseOperation2 3901// API call, and error handling. 3902// 3903// This method is useful when you want to inject custom logic or configuration 3904// into the SDK's request lifecycle. Such as custom headers, or retry logic. 3905// 3906// 3907// // Example sending a request using the InputService21TestCaseOperation2Request method. 3908// req, resp := client.InputService21TestCaseOperation2Request(params) 3909// 3910// err := req.Send() 3911// if err == nil { // resp is now filled 3912// fmt.Println(resp) 3913// } 3914func (c *InputService21ProtocolTest) InputService21TestCaseOperation2Request(input *InputService21TestShapeInputService21TestCaseOperation2Input) (req *request.Request, output *InputService21TestShapeInputService21TestCaseOperation2Output) { 3915 op := &request.Operation{ 3916 Name: opInputService21TestCaseOperation2, 3917 HTTPMethod: "POST", 3918 HTTPPath: "/path?abc=mno", 3919 } 3920 3921 if input == nil { 3922 input = &InputService21TestShapeInputService21TestCaseOperation2Input{} 3923 } 3924 3925 output = &InputService21TestShapeInputService21TestCaseOperation2Output{} 3926 req = c.newRequest(op, input, output) 3927 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 3928 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 3929 return 3930} 3931 3932// InputService21TestCaseOperation2 API operation for . 3933// 3934// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 3935// with awserr.Error's Code and Message methods to get detailed information about 3936// the error. 3937// 3938// See the AWS API reference guide for 's 3939// API operation InputService21TestCaseOperation2 for usage and error information. 3940func (c *InputService21ProtocolTest) InputService21TestCaseOperation2(input *InputService21TestShapeInputService21TestCaseOperation2Input) (*InputService21TestShapeInputService21TestCaseOperation2Output, error) { 3941 req, out := c.InputService21TestCaseOperation2Request(input) 3942 return out, req.Send() 3943} 3944 3945// InputService21TestCaseOperation2WithContext is the same as InputService21TestCaseOperation2 with the addition of 3946// the ability to pass a context and additional request options. 3947// 3948// See InputService21TestCaseOperation2 for details on how to use this API operation. 3949// 3950// The context must be non-nil and will be used for request cancellation. If 3951// the context is nil a panic will occur. In the future the SDK may create 3952// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 3953// for more information on using Contexts. 3954func (c *InputService21ProtocolTest) InputService21TestCaseOperation2WithContext(ctx aws.Context, input *InputService21TestShapeInputService21TestCaseOperation2Input, opts ...request.Option) (*InputService21TestShapeInputService21TestCaseOperation2Output, error) { 3955 req, out := c.InputService21TestCaseOperation2Request(input) 3956 req.SetContext(ctx) 3957 req.ApplyOptions(opts...) 3958 return out, req.Send() 3959} 3960 3961type InputService21TestShapeInputService21TestCaseOperation1Output struct { 3962 _ struct{} `type:"structure"` 3963} 3964 3965type InputService21TestShapeInputService21TestCaseOperation2Input struct { 3966 _ struct{} `type:"structure"` 3967 3968 Foo *string `location:"querystring" locationName:"param-name" type:"string"` 3969} 3970 3971// SetFoo sets the Foo field's value. 3972func (s *InputService21TestShapeInputService21TestCaseOperation2Input) SetFoo(v string) *InputService21TestShapeInputService21TestCaseOperation2Input { 3973 s.Foo = &v 3974 return s 3975} 3976 3977type InputService21TestShapeInputService21TestCaseOperation2Output struct { 3978 _ struct{} `type:"structure"` 3979} 3980 3981// InputService22ProtocolTest provides the API operation methods for making requests to 3982// . See this package's package overview docs 3983// for details on the service. 3984// 3985// InputService22ProtocolTest methods are safe to use concurrently. It is not safe to 3986// modify mutate any of the struct's properties though. 3987type InputService22ProtocolTest struct { 3988 *client.Client 3989} 3990 3991// New creates a new instance of the InputService22ProtocolTest client with a session. 3992// If additional configuration is needed for the client instance use the optional 3993// aws.Config parameter to add your extra config. 3994// 3995// Example: 3996// // Create a InputService22ProtocolTest client from just a session. 3997// svc := inputservice22protocoltest.New(mySession) 3998// 3999// // Create a InputService22ProtocolTest client with additional configuration 4000// svc := inputservice22protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 4001func NewInputService22ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService22ProtocolTest { 4002 c := p.ClientConfig("inputservice22protocoltest", cfgs...) 4003 return newInputService22ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 4004} 4005 4006// newClient creates, initializes and returns a new service client instance. 4007func newInputService22ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService22ProtocolTest { 4008 svc := &InputService22ProtocolTest{ 4009 Client: client.New( 4010 cfg, 4011 metadata.ClientInfo{ 4012 ServiceName: "inputservice22protocoltest", 4013 SigningName: signingName, 4014 SigningRegion: signingRegion, 4015 Endpoint: endpoint, 4016 APIVersion: "2014-01-01", 4017 }, 4018 handlers, 4019 ), 4020 } 4021 4022 // Handlers 4023 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 4024 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 4025 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 4026 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 4027 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 4028 4029 return svc 4030} 4031 4032// newRequest creates a new request for a InputService22ProtocolTest operation and runs any 4033// custom request initialization. 4034func (c *InputService22ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 4035 req := c.NewRequest(op, params, data) 4036 4037 return req 4038} 4039 4040const opInputService22TestCaseOperation1 = "OperationName" 4041 4042// InputService22TestCaseOperation1Request generates a "aws/request.Request" representing the 4043// client's request for the InputService22TestCaseOperation1 operation. The "output" return 4044// value will be populated with the request's response once the request complets 4045// successfuly. 4046// 4047// Use "Send" method on the returned Request to send the API call to the service. 4048// the "output" return value is not valid until after Send returns without error. 4049// 4050// See InputService22TestCaseOperation1 for more information on using the InputService22TestCaseOperation1 4051// API call, and error handling. 4052// 4053// This method is useful when you want to inject custom logic or configuration 4054// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4055// 4056// 4057// // Example sending a request using the InputService22TestCaseOperation1Request method. 4058// req, resp := client.InputService22TestCaseOperation1Request(params) 4059// 4060// err := req.Send() 4061// if err == nil { // resp is now filled 4062// fmt.Println(resp) 4063// } 4064func (c *InputService22ProtocolTest) InputService22TestCaseOperation1Request(input *InputService22TestShapeInputService22TestCaseOperation6Input) (req *request.Request, output *InputService22TestShapeInputService22TestCaseOperation1Output) { 4065 op := &request.Operation{ 4066 Name: opInputService22TestCaseOperation1, 4067 HTTPMethod: "POST", 4068 HTTPPath: "/path", 4069 } 4070 4071 if input == nil { 4072 input = &InputService22TestShapeInputService22TestCaseOperation6Input{} 4073 } 4074 4075 output = &InputService22TestShapeInputService22TestCaseOperation1Output{} 4076 req = c.newRequest(op, input, output) 4077 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 4078 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 4079 return 4080} 4081 4082// InputService22TestCaseOperation1 API operation for . 4083// 4084// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4085// with awserr.Error's Code and Message methods to get detailed information about 4086// the error. 4087// 4088// See the AWS API reference guide for 's 4089// API operation InputService22TestCaseOperation1 for usage and error information. 4090func (c *InputService22ProtocolTest) InputService22TestCaseOperation1(input *InputService22TestShapeInputService22TestCaseOperation6Input) (*InputService22TestShapeInputService22TestCaseOperation1Output, error) { 4091 req, out := c.InputService22TestCaseOperation1Request(input) 4092 return out, req.Send() 4093} 4094 4095// InputService22TestCaseOperation1WithContext is the same as InputService22TestCaseOperation1 with the addition of 4096// the ability to pass a context and additional request options. 4097// 4098// See InputService22TestCaseOperation1 for details on how to use this API operation. 4099// 4100// The context must be non-nil and will be used for request cancellation. If 4101// the context is nil a panic will occur. In the future the SDK may create 4102// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4103// for more information on using Contexts. 4104func (c *InputService22ProtocolTest) InputService22TestCaseOperation1WithContext(ctx aws.Context, input *InputService22TestShapeInputService22TestCaseOperation6Input, opts ...request.Option) (*InputService22TestShapeInputService22TestCaseOperation1Output, error) { 4105 req, out := c.InputService22TestCaseOperation1Request(input) 4106 req.SetContext(ctx) 4107 req.ApplyOptions(opts...) 4108 return out, req.Send() 4109} 4110 4111const opInputService22TestCaseOperation2 = "OperationName" 4112 4113// InputService22TestCaseOperation2Request generates a "aws/request.Request" representing the 4114// client's request for the InputService22TestCaseOperation2 operation. The "output" return 4115// value will be populated with the request's response once the request complets 4116// successfuly. 4117// 4118// Use "Send" method on the returned Request to send the API call to the service. 4119// the "output" return value is not valid until after Send returns without error. 4120// 4121// See InputService22TestCaseOperation2 for more information on using the InputService22TestCaseOperation2 4122// API call, and error handling. 4123// 4124// This method is useful when you want to inject custom logic or configuration 4125// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4126// 4127// 4128// // Example sending a request using the InputService22TestCaseOperation2Request method. 4129// req, resp := client.InputService22TestCaseOperation2Request(params) 4130// 4131// err := req.Send() 4132// if err == nil { // resp is now filled 4133// fmt.Println(resp) 4134// } 4135func (c *InputService22ProtocolTest) InputService22TestCaseOperation2Request(input *InputService22TestShapeInputService22TestCaseOperation6Input) (req *request.Request, output *InputService22TestShapeInputService22TestCaseOperation2Output) { 4136 op := &request.Operation{ 4137 Name: opInputService22TestCaseOperation2, 4138 HTTPMethod: "POST", 4139 HTTPPath: "/path", 4140 } 4141 4142 if input == nil { 4143 input = &InputService22TestShapeInputService22TestCaseOperation6Input{} 4144 } 4145 4146 output = &InputService22TestShapeInputService22TestCaseOperation2Output{} 4147 req = c.newRequest(op, input, output) 4148 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 4149 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 4150 return 4151} 4152 4153// InputService22TestCaseOperation2 API operation for . 4154// 4155// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4156// with awserr.Error's Code and Message methods to get detailed information about 4157// the error. 4158// 4159// See the AWS API reference guide for 's 4160// API operation InputService22TestCaseOperation2 for usage and error information. 4161func (c *InputService22ProtocolTest) InputService22TestCaseOperation2(input *InputService22TestShapeInputService22TestCaseOperation6Input) (*InputService22TestShapeInputService22TestCaseOperation2Output, error) { 4162 req, out := c.InputService22TestCaseOperation2Request(input) 4163 return out, req.Send() 4164} 4165 4166// InputService22TestCaseOperation2WithContext is the same as InputService22TestCaseOperation2 with the addition of 4167// the ability to pass a context and additional request options. 4168// 4169// See InputService22TestCaseOperation2 for details on how to use this API operation. 4170// 4171// The context must be non-nil and will be used for request cancellation. If 4172// the context is nil a panic will occur. In the future the SDK may create 4173// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4174// for more information on using Contexts. 4175func (c *InputService22ProtocolTest) InputService22TestCaseOperation2WithContext(ctx aws.Context, input *InputService22TestShapeInputService22TestCaseOperation6Input, opts ...request.Option) (*InputService22TestShapeInputService22TestCaseOperation2Output, error) { 4176 req, out := c.InputService22TestCaseOperation2Request(input) 4177 req.SetContext(ctx) 4178 req.ApplyOptions(opts...) 4179 return out, req.Send() 4180} 4181 4182const opInputService22TestCaseOperation3 = "OperationName" 4183 4184// InputService22TestCaseOperation3Request generates a "aws/request.Request" representing the 4185// client's request for the InputService22TestCaseOperation3 operation. The "output" return 4186// value will be populated with the request's response once the request complets 4187// successfuly. 4188// 4189// Use "Send" method on the returned Request to send the API call to the service. 4190// the "output" return value is not valid until after Send returns without error. 4191// 4192// See InputService22TestCaseOperation3 for more information on using the InputService22TestCaseOperation3 4193// API call, and error handling. 4194// 4195// This method is useful when you want to inject custom logic or configuration 4196// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4197// 4198// 4199// // Example sending a request using the InputService22TestCaseOperation3Request method. 4200// req, resp := client.InputService22TestCaseOperation3Request(params) 4201// 4202// err := req.Send() 4203// if err == nil { // resp is now filled 4204// fmt.Println(resp) 4205// } 4206func (c *InputService22ProtocolTest) InputService22TestCaseOperation3Request(input *InputService22TestShapeInputService22TestCaseOperation6Input) (req *request.Request, output *InputService22TestShapeInputService22TestCaseOperation3Output) { 4207 op := &request.Operation{ 4208 Name: opInputService22TestCaseOperation3, 4209 HTTPMethod: "POST", 4210 HTTPPath: "/path", 4211 } 4212 4213 if input == nil { 4214 input = &InputService22TestShapeInputService22TestCaseOperation6Input{} 4215 } 4216 4217 output = &InputService22TestShapeInputService22TestCaseOperation3Output{} 4218 req = c.newRequest(op, input, output) 4219 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 4220 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 4221 return 4222} 4223 4224// InputService22TestCaseOperation3 API operation for . 4225// 4226// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4227// with awserr.Error's Code and Message methods to get detailed information about 4228// the error. 4229// 4230// See the AWS API reference guide for 's 4231// API operation InputService22TestCaseOperation3 for usage and error information. 4232func (c *InputService22ProtocolTest) InputService22TestCaseOperation3(input *InputService22TestShapeInputService22TestCaseOperation6Input) (*InputService22TestShapeInputService22TestCaseOperation3Output, error) { 4233 req, out := c.InputService22TestCaseOperation3Request(input) 4234 return out, req.Send() 4235} 4236 4237// InputService22TestCaseOperation3WithContext is the same as InputService22TestCaseOperation3 with the addition of 4238// the ability to pass a context and additional request options. 4239// 4240// See InputService22TestCaseOperation3 for details on how to use this API operation. 4241// 4242// The context must be non-nil and will be used for request cancellation. If 4243// the context is nil a panic will occur. In the future the SDK may create 4244// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4245// for more information on using Contexts. 4246func (c *InputService22ProtocolTest) InputService22TestCaseOperation3WithContext(ctx aws.Context, input *InputService22TestShapeInputService22TestCaseOperation6Input, opts ...request.Option) (*InputService22TestShapeInputService22TestCaseOperation3Output, error) { 4247 req, out := c.InputService22TestCaseOperation3Request(input) 4248 req.SetContext(ctx) 4249 req.ApplyOptions(opts...) 4250 return out, req.Send() 4251} 4252 4253const opInputService22TestCaseOperation4 = "OperationName" 4254 4255// InputService22TestCaseOperation4Request generates a "aws/request.Request" representing the 4256// client's request for the InputService22TestCaseOperation4 operation. The "output" return 4257// value will be populated with the request's response once the request complets 4258// successfuly. 4259// 4260// Use "Send" method on the returned Request to send the API call to the service. 4261// the "output" return value is not valid until after Send returns without error. 4262// 4263// See InputService22TestCaseOperation4 for more information on using the InputService22TestCaseOperation4 4264// API call, and error handling. 4265// 4266// This method is useful when you want to inject custom logic or configuration 4267// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4268// 4269// 4270// // Example sending a request using the InputService22TestCaseOperation4Request method. 4271// req, resp := client.InputService22TestCaseOperation4Request(params) 4272// 4273// err := req.Send() 4274// if err == nil { // resp is now filled 4275// fmt.Println(resp) 4276// } 4277func (c *InputService22ProtocolTest) InputService22TestCaseOperation4Request(input *InputService22TestShapeInputService22TestCaseOperation6Input) (req *request.Request, output *InputService22TestShapeInputService22TestCaseOperation4Output) { 4278 op := &request.Operation{ 4279 Name: opInputService22TestCaseOperation4, 4280 HTTPMethod: "POST", 4281 HTTPPath: "/path", 4282 } 4283 4284 if input == nil { 4285 input = &InputService22TestShapeInputService22TestCaseOperation6Input{} 4286 } 4287 4288 output = &InputService22TestShapeInputService22TestCaseOperation4Output{} 4289 req = c.newRequest(op, input, output) 4290 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 4291 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 4292 return 4293} 4294 4295// InputService22TestCaseOperation4 API operation for . 4296// 4297// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4298// with awserr.Error's Code and Message methods to get detailed information about 4299// the error. 4300// 4301// See the AWS API reference guide for 's 4302// API operation InputService22TestCaseOperation4 for usage and error information. 4303func (c *InputService22ProtocolTest) InputService22TestCaseOperation4(input *InputService22TestShapeInputService22TestCaseOperation6Input) (*InputService22TestShapeInputService22TestCaseOperation4Output, error) { 4304 req, out := c.InputService22TestCaseOperation4Request(input) 4305 return out, req.Send() 4306} 4307 4308// InputService22TestCaseOperation4WithContext is the same as InputService22TestCaseOperation4 with the addition of 4309// the ability to pass a context and additional request options. 4310// 4311// See InputService22TestCaseOperation4 for details on how to use this API operation. 4312// 4313// The context must be non-nil and will be used for request cancellation. If 4314// the context is nil a panic will occur. In the future the SDK may create 4315// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4316// for more information on using Contexts. 4317func (c *InputService22ProtocolTest) InputService22TestCaseOperation4WithContext(ctx aws.Context, input *InputService22TestShapeInputService22TestCaseOperation6Input, opts ...request.Option) (*InputService22TestShapeInputService22TestCaseOperation4Output, error) { 4318 req, out := c.InputService22TestCaseOperation4Request(input) 4319 req.SetContext(ctx) 4320 req.ApplyOptions(opts...) 4321 return out, req.Send() 4322} 4323 4324const opInputService22TestCaseOperation5 = "OperationName" 4325 4326// InputService22TestCaseOperation5Request generates a "aws/request.Request" representing the 4327// client's request for the InputService22TestCaseOperation5 operation. The "output" return 4328// value will be populated with the request's response once the request complets 4329// successfuly. 4330// 4331// Use "Send" method on the returned Request to send the API call to the service. 4332// the "output" return value is not valid until after Send returns without error. 4333// 4334// See InputService22TestCaseOperation5 for more information on using the InputService22TestCaseOperation5 4335// API call, and error handling. 4336// 4337// This method is useful when you want to inject custom logic or configuration 4338// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4339// 4340// 4341// // Example sending a request using the InputService22TestCaseOperation5Request method. 4342// req, resp := client.InputService22TestCaseOperation5Request(params) 4343// 4344// err := req.Send() 4345// if err == nil { // resp is now filled 4346// fmt.Println(resp) 4347// } 4348func (c *InputService22ProtocolTest) InputService22TestCaseOperation5Request(input *InputService22TestShapeInputService22TestCaseOperation6Input) (req *request.Request, output *InputService22TestShapeInputService22TestCaseOperation5Output) { 4349 op := &request.Operation{ 4350 Name: opInputService22TestCaseOperation5, 4351 HTTPMethod: "POST", 4352 HTTPPath: "/path", 4353 } 4354 4355 if input == nil { 4356 input = &InputService22TestShapeInputService22TestCaseOperation6Input{} 4357 } 4358 4359 output = &InputService22TestShapeInputService22TestCaseOperation5Output{} 4360 req = c.newRequest(op, input, output) 4361 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 4362 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 4363 return 4364} 4365 4366// InputService22TestCaseOperation5 API operation for . 4367// 4368// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4369// with awserr.Error's Code and Message methods to get detailed information about 4370// the error. 4371// 4372// See the AWS API reference guide for 's 4373// API operation InputService22TestCaseOperation5 for usage and error information. 4374func (c *InputService22ProtocolTest) InputService22TestCaseOperation5(input *InputService22TestShapeInputService22TestCaseOperation6Input) (*InputService22TestShapeInputService22TestCaseOperation5Output, error) { 4375 req, out := c.InputService22TestCaseOperation5Request(input) 4376 return out, req.Send() 4377} 4378 4379// InputService22TestCaseOperation5WithContext is the same as InputService22TestCaseOperation5 with the addition of 4380// the ability to pass a context and additional request options. 4381// 4382// See InputService22TestCaseOperation5 for details on how to use this API operation. 4383// 4384// The context must be non-nil and will be used for request cancellation. If 4385// the context is nil a panic will occur. In the future the SDK may create 4386// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4387// for more information on using Contexts. 4388func (c *InputService22ProtocolTest) InputService22TestCaseOperation5WithContext(ctx aws.Context, input *InputService22TestShapeInputService22TestCaseOperation6Input, opts ...request.Option) (*InputService22TestShapeInputService22TestCaseOperation5Output, error) { 4389 req, out := c.InputService22TestCaseOperation5Request(input) 4390 req.SetContext(ctx) 4391 req.ApplyOptions(opts...) 4392 return out, req.Send() 4393} 4394 4395const opInputService22TestCaseOperation6 = "OperationName" 4396 4397// InputService22TestCaseOperation6Request generates a "aws/request.Request" representing the 4398// client's request for the InputService22TestCaseOperation6 operation. The "output" return 4399// value will be populated with the request's response once the request complets 4400// successfuly. 4401// 4402// Use "Send" method on the returned Request to send the API call to the service. 4403// the "output" return value is not valid until after Send returns without error. 4404// 4405// See InputService22TestCaseOperation6 for more information on using the InputService22TestCaseOperation6 4406// API call, and error handling. 4407// 4408// This method is useful when you want to inject custom logic or configuration 4409// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4410// 4411// 4412// // Example sending a request using the InputService22TestCaseOperation6Request method. 4413// req, resp := client.InputService22TestCaseOperation6Request(params) 4414// 4415// err := req.Send() 4416// if err == nil { // resp is now filled 4417// fmt.Println(resp) 4418// } 4419func (c *InputService22ProtocolTest) InputService22TestCaseOperation6Request(input *InputService22TestShapeInputService22TestCaseOperation6Input) (req *request.Request, output *InputService22TestShapeInputService22TestCaseOperation6Output) { 4420 op := &request.Operation{ 4421 Name: opInputService22TestCaseOperation6, 4422 HTTPMethod: "POST", 4423 HTTPPath: "/path", 4424 } 4425 4426 if input == nil { 4427 input = &InputService22TestShapeInputService22TestCaseOperation6Input{} 4428 } 4429 4430 output = &InputService22TestShapeInputService22TestCaseOperation6Output{} 4431 req = c.newRequest(op, input, output) 4432 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 4433 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 4434 return 4435} 4436 4437// InputService22TestCaseOperation6 API operation for . 4438// 4439// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4440// with awserr.Error's Code and Message methods to get detailed information about 4441// the error. 4442// 4443// See the AWS API reference guide for 's 4444// API operation InputService22TestCaseOperation6 for usage and error information. 4445func (c *InputService22ProtocolTest) InputService22TestCaseOperation6(input *InputService22TestShapeInputService22TestCaseOperation6Input) (*InputService22TestShapeInputService22TestCaseOperation6Output, error) { 4446 req, out := c.InputService22TestCaseOperation6Request(input) 4447 return out, req.Send() 4448} 4449 4450// InputService22TestCaseOperation6WithContext is the same as InputService22TestCaseOperation6 with the addition of 4451// the ability to pass a context and additional request options. 4452// 4453// See InputService22TestCaseOperation6 for details on how to use this API operation. 4454// 4455// The context must be non-nil and will be used for request cancellation. If 4456// the context is nil a panic will occur. In the future the SDK may create 4457// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4458// for more information on using Contexts. 4459func (c *InputService22ProtocolTest) InputService22TestCaseOperation6WithContext(ctx aws.Context, input *InputService22TestShapeInputService22TestCaseOperation6Input, opts ...request.Option) (*InputService22TestShapeInputService22TestCaseOperation6Output, error) { 4460 req, out := c.InputService22TestCaseOperation6Request(input) 4461 req.SetContext(ctx) 4462 req.ApplyOptions(opts...) 4463 return out, req.Send() 4464} 4465 4466type InputService22TestShapeInputService22TestCaseOperation1Output struct { 4467 _ struct{} `type:"structure"` 4468} 4469 4470type InputService22TestShapeInputService22TestCaseOperation2Output struct { 4471 _ struct{} `type:"structure"` 4472} 4473 4474type InputService22TestShapeInputService22TestCaseOperation3Output struct { 4475 _ struct{} `type:"structure"` 4476} 4477 4478type InputService22TestShapeInputService22TestCaseOperation4Output struct { 4479 _ struct{} `type:"structure"` 4480} 4481 4482type InputService22TestShapeInputService22TestCaseOperation5Output struct { 4483 _ struct{} `type:"structure"` 4484} 4485 4486type InputService22TestShapeInputService22TestCaseOperation6Input struct { 4487 _ struct{} `locationName:"OperationRequest" type:"structure" xmlURI:"https://foo/"` 4488 4489 RecursiveStruct *InputService22TestShapeRecursiveStructType `type:"structure"` 4490} 4491 4492// SetRecursiveStruct sets the RecursiveStruct field's value. 4493func (s *InputService22TestShapeInputService22TestCaseOperation6Input) SetRecursiveStruct(v *InputService22TestShapeRecursiveStructType) *InputService22TestShapeInputService22TestCaseOperation6Input { 4494 s.RecursiveStruct = v 4495 return s 4496} 4497 4498type InputService22TestShapeInputService22TestCaseOperation6Output struct { 4499 _ struct{} `type:"structure"` 4500} 4501 4502type InputService22TestShapeRecursiveStructType struct { 4503 _ struct{} `type:"structure"` 4504 4505 NoRecurse *string `type:"string"` 4506 4507 RecursiveList []*InputService22TestShapeRecursiveStructType `type:"list"` 4508 4509 RecursiveMap map[string]*InputService22TestShapeRecursiveStructType `type:"map"` 4510 4511 RecursiveStruct *InputService22TestShapeRecursiveStructType `type:"structure"` 4512} 4513 4514// SetNoRecurse sets the NoRecurse field's value. 4515func (s *InputService22TestShapeRecursiveStructType) SetNoRecurse(v string) *InputService22TestShapeRecursiveStructType { 4516 s.NoRecurse = &v 4517 return s 4518} 4519 4520// SetRecursiveList sets the RecursiveList field's value. 4521func (s *InputService22TestShapeRecursiveStructType) SetRecursiveList(v []*InputService22TestShapeRecursiveStructType) *InputService22TestShapeRecursiveStructType { 4522 s.RecursiveList = v 4523 return s 4524} 4525 4526// SetRecursiveMap sets the RecursiveMap field's value. 4527func (s *InputService22TestShapeRecursiveStructType) SetRecursiveMap(v map[string]*InputService22TestShapeRecursiveStructType) *InputService22TestShapeRecursiveStructType { 4528 s.RecursiveMap = v 4529 return s 4530} 4531 4532// SetRecursiveStruct sets the RecursiveStruct field's value. 4533func (s *InputService22TestShapeRecursiveStructType) SetRecursiveStruct(v *InputService22TestShapeRecursiveStructType) *InputService22TestShapeRecursiveStructType { 4534 s.RecursiveStruct = v 4535 return s 4536} 4537 4538// InputService23ProtocolTest provides the API operation methods for making requests to 4539// . See this package's package overview docs 4540// for details on the service. 4541// 4542// InputService23ProtocolTest methods are safe to use concurrently. It is not safe to 4543// modify mutate any of the struct's properties though. 4544type InputService23ProtocolTest struct { 4545 *client.Client 4546} 4547 4548// New creates a new instance of the InputService23ProtocolTest client with a session. 4549// If additional configuration is needed for the client instance use the optional 4550// aws.Config parameter to add your extra config. 4551// 4552// Example: 4553// // Create a InputService23ProtocolTest client from just a session. 4554// svc := inputservice23protocoltest.New(mySession) 4555// 4556// // Create a InputService23ProtocolTest client with additional configuration 4557// svc := inputservice23protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 4558func NewInputService23ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService23ProtocolTest { 4559 c := p.ClientConfig("inputservice23protocoltest", cfgs...) 4560 return newInputService23ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 4561} 4562 4563// newClient creates, initializes and returns a new service client instance. 4564func newInputService23ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService23ProtocolTest { 4565 svc := &InputService23ProtocolTest{ 4566 Client: client.New( 4567 cfg, 4568 metadata.ClientInfo{ 4569 ServiceName: "inputservice23protocoltest", 4570 SigningName: signingName, 4571 SigningRegion: signingRegion, 4572 Endpoint: endpoint, 4573 APIVersion: "2014-01-01", 4574 }, 4575 handlers, 4576 ), 4577 } 4578 4579 // Handlers 4580 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 4581 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 4582 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 4583 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 4584 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 4585 4586 return svc 4587} 4588 4589// newRequest creates a new request for a InputService23ProtocolTest operation and runs any 4590// custom request initialization. 4591func (c *InputService23ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 4592 req := c.NewRequest(op, params, data) 4593 4594 return req 4595} 4596 4597const opInputService23TestCaseOperation1 = "OperationName" 4598 4599// InputService23TestCaseOperation1Request generates a "aws/request.Request" representing the 4600// client's request for the InputService23TestCaseOperation1 operation. The "output" return 4601// value will be populated with the request's response once the request complets 4602// successfuly. 4603// 4604// Use "Send" method on the returned Request to send the API call to the service. 4605// the "output" return value is not valid until after Send returns without error. 4606// 4607// See InputService23TestCaseOperation1 for more information on using the InputService23TestCaseOperation1 4608// API call, and error handling. 4609// 4610// This method is useful when you want to inject custom logic or configuration 4611// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4612// 4613// 4614// // Example sending a request using the InputService23TestCaseOperation1Request method. 4615// req, resp := client.InputService23TestCaseOperation1Request(params) 4616// 4617// err := req.Send() 4618// if err == nil { // resp is now filled 4619// fmt.Println(resp) 4620// } 4621func (c *InputService23ProtocolTest) InputService23TestCaseOperation1Request(input *InputService23TestShapeInputService23TestCaseOperation1Input) (req *request.Request, output *InputService23TestShapeInputService23TestCaseOperation1Output) { 4622 op := &request.Operation{ 4623 Name: opInputService23TestCaseOperation1, 4624 HTTPMethod: "POST", 4625 HTTPPath: "/path", 4626 } 4627 4628 if input == nil { 4629 input = &InputService23TestShapeInputService23TestCaseOperation1Input{} 4630 } 4631 4632 output = &InputService23TestShapeInputService23TestCaseOperation1Output{} 4633 req = c.newRequest(op, input, output) 4634 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 4635 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 4636 return 4637} 4638 4639// InputService23TestCaseOperation1 API operation for . 4640// 4641// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4642// with awserr.Error's Code and Message methods to get detailed information about 4643// the error. 4644// 4645// See the AWS API reference guide for 's 4646// API operation InputService23TestCaseOperation1 for usage and error information. 4647func (c *InputService23ProtocolTest) InputService23TestCaseOperation1(input *InputService23TestShapeInputService23TestCaseOperation1Input) (*InputService23TestShapeInputService23TestCaseOperation1Output, error) { 4648 req, out := c.InputService23TestCaseOperation1Request(input) 4649 return out, req.Send() 4650} 4651 4652// InputService23TestCaseOperation1WithContext is the same as InputService23TestCaseOperation1 with the addition of 4653// the ability to pass a context and additional request options. 4654// 4655// See InputService23TestCaseOperation1 for details on how to use this API operation. 4656// 4657// The context must be non-nil and will be used for request cancellation. If 4658// the context is nil a panic will occur. In the future the SDK may create 4659// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4660// for more information on using Contexts. 4661func (c *InputService23ProtocolTest) InputService23TestCaseOperation1WithContext(ctx aws.Context, input *InputService23TestShapeInputService23TestCaseOperation1Input, opts ...request.Option) (*InputService23TestShapeInputService23TestCaseOperation1Output, error) { 4662 req, out := c.InputService23TestCaseOperation1Request(input) 4663 req.SetContext(ctx) 4664 req.ApplyOptions(opts...) 4665 return out, req.Send() 4666} 4667 4668type InputService23TestShapeInputService23TestCaseOperation1Input struct { 4669 _ struct{} `type:"structure"` 4670 4671 TimeArgInHeader *time.Time `location:"header" locationName:"x-amz-timearg" type:"timestamp" timestampFormat:"rfc822"` 4672} 4673 4674// SetTimeArgInHeader sets the TimeArgInHeader field's value. 4675func (s *InputService23TestShapeInputService23TestCaseOperation1Input) SetTimeArgInHeader(v time.Time) *InputService23TestShapeInputService23TestCaseOperation1Input { 4676 s.TimeArgInHeader = &v 4677 return s 4678} 4679 4680type InputService23TestShapeInputService23TestCaseOperation1Output struct { 4681 _ struct{} `type:"structure"` 4682} 4683 4684// InputService24ProtocolTest provides the API operation methods for making requests to 4685// . See this package's package overview docs 4686// for details on the service. 4687// 4688// InputService24ProtocolTest methods are safe to use concurrently. It is not safe to 4689// modify mutate any of the struct's properties though. 4690type InputService24ProtocolTest struct { 4691 *client.Client 4692} 4693 4694// New creates a new instance of the InputService24ProtocolTest client with a session. 4695// If additional configuration is needed for the client instance use the optional 4696// aws.Config parameter to add your extra config. 4697// 4698// Example: 4699// // Create a InputService24ProtocolTest client from just a session. 4700// svc := inputservice24protocoltest.New(mySession) 4701// 4702// // Create a InputService24ProtocolTest client with additional configuration 4703// svc := inputservice24protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 4704func NewInputService24ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService24ProtocolTest { 4705 c := p.ClientConfig("inputservice24protocoltest", cfgs...) 4706 return newInputService24ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 4707} 4708 4709// newClient creates, initializes and returns a new service client instance. 4710func newInputService24ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService24ProtocolTest { 4711 svc := &InputService24ProtocolTest{ 4712 Client: client.New( 4713 cfg, 4714 metadata.ClientInfo{ 4715 ServiceName: "inputservice24protocoltest", 4716 SigningName: signingName, 4717 SigningRegion: signingRegion, 4718 Endpoint: endpoint, 4719 APIVersion: "2014-01-01", 4720 }, 4721 handlers, 4722 ), 4723 } 4724 4725 // Handlers 4726 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 4727 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 4728 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 4729 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 4730 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 4731 4732 return svc 4733} 4734 4735// newRequest creates a new request for a InputService24ProtocolTest operation and runs any 4736// custom request initialization. 4737func (c *InputService24ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 4738 req := c.NewRequest(op, params, data) 4739 4740 return req 4741} 4742 4743const opInputService24TestCaseOperation1 = "OperationName" 4744 4745// InputService24TestCaseOperation1Request generates a "aws/request.Request" representing the 4746// client's request for the InputService24TestCaseOperation1 operation. The "output" return 4747// value will be populated with the request's response once the request complets 4748// successfuly. 4749// 4750// Use "Send" method on the returned Request to send the API call to the service. 4751// the "output" return value is not valid until after Send returns without error. 4752// 4753// See InputService24TestCaseOperation1 for more information on using the InputService24TestCaseOperation1 4754// API call, and error handling. 4755// 4756// This method is useful when you want to inject custom logic or configuration 4757// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4758// 4759// 4760// // Example sending a request using the InputService24TestCaseOperation1Request method. 4761// req, resp := client.InputService24TestCaseOperation1Request(params) 4762// 4763// err := req.Send() 4764// if err == nil { // resp is now filled 4765// fmt.Println(resp) 4766// } 4767func (c *InputService24ProtocolTest) InputService24TestCaseOperation1Request(input *InputService24TestShapeInputService24TestCaseOperation2Input) (req *request.Request, output *InputService24TestShapeInputService24TestCaseOperation1Output) { 4768 op := &request.Operation{ 4769 Name: opInputService24TestCaseOperation1, 4770 HTTPMethod: "POST", 4771 HTTPPath: "/path", 4772 } 4773 4774 if input == nil { 4775 input = &InputService24TestShapeInputService24TestCaseOperation2Input{} 4776 } 4777 4778 output = &InputService24TestShapeInputService24TestCaseOperation1Output{} 4779 req = c.newRequest(op, input, output) 4780 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 4781 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 4782 return 4783} 4784 4785// InputService24TestCaseOperation1 API operation for . 4786// 4787// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4788// with awserr.Error's Code and Message methods to get detailed information about 4789// the error. 4790// 4791// See the AWS API reference guide for 's 4792// API operation InputService24TestCaseOperation1 for usage and error information. 4793func (c *InputService24ProtocolTest) InputService24TestCaseOperation1(input *InputService24TestShapeInputService24TestCaseOperation2Input) (*InputService24TestShapeInputService24TestCaseOperation1Output, error) { 4794 req, out := c.InputService24TestCaseOperation1Request(input) 4795 return out, req.Send() 4796} 4797 4798// InputService24TestCaseOperation1WithContext is the same as InputService24TestCaseOperation1 with the addition of 4799// the ability to pass a context and additional request options. 4800// 4801// See InputService24TestCaseOperation1 for details on how to use this API operation. 4802// 4803// The context must be non-nil and will be used for request cancellation. If 4804// the context is nil a panic will occur. In the future the SDK may create 4805// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4806// for more information on using Contexts. 4807func (c *InputService24ProtocolTest) InputService24TestCaseOperation1WithContext(ctx aws.Context, input *InputService24TestShapeInputService24TestCaseOperation2Input, opts ...request.Option) (*InputService24TestShapeInputService24TestCaseOperation1Output, error) { 4808 req, out := c.InputService24TestCaseOperation1Request(input) 4809 req.SetContext(ctx) 4810 req.ApplyOptions(opts...) 4811 return out, req.Send() 4812} 4813 4814const opInputService24TestCaseOperation2 = "OperationName" 4815 4816// InputService24TestCaseOperation2Request generates a "aws/request.Request" representing the 4817// client's request for the InputService24TestCaseOperation2 operation. The "output" return 4818// value will be populated with the request's response once the request complets 4819// successfuly. 4820// 4821// Use "Send" method on the returned Request to send the API call to the service. 4822// the "output" return value is not valid until after Send returns without error. 4823// 4824// See InputService24TestCaseOperation2 for more information on using the InputService24TestCaseOperation2 4825// API call, and error handling. 4826// 4827// This method is useful when you want to inject custom logic or configuration 4828// into the SDK's request lifecycle. Such as custom headers, or retry logic. 4829// 4830// 4831// // Example sending a request using the InputService24TestCaseOperation2Request method. 4832// req, resp := client.InputService24TestCaseOperation2Request(params) 4833// 4834// err := req.Send() 4835// if err == nil { // resp is now filled 4836// fmt.Println(resp) 4837// } 4838func (c *InputService24ProtocolTest) InputService24TestCaseOperation2Request(input *InputService24TestShapeInputService24TestCaseOperation2Input) (req *request.Request, output *InputService24TestShapeInputService24TestCaseOperation2Output) { 4839 op := &request.Operation{ 4840 Name: opInputService24TestCaseOperation2, 4841 HTTPMethod: "POST", 4842 HTTPPath: "/path", 4843 } 4844 4845 if input == nil { 4846 input = &InputService24TestShapeInputService24TestCaseOperation2Input{} 4847 } 4848 4849 output = &InputService24TestShapeInputService24TestCaseOperation2Output{} 4850 req = c.newRequest(op, input, output) 4851 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 4852 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 4853 return 4854} 4855 4856// InputService24TestCaseOperation2 API operation for . 4857// 4858// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 4859// with awserr.Error's Code and Message methods to get detailed information about 4860// the error. 4861// 4862// See the AWS API reference guide for 's 4863// API operation InputService24TestCaseOperation2 for usage and error information. 4864func (c *InputService24ProtocolTest) InputService24TestCaseOperation2(input *InputService24TestShapeInputService24TestCaseOperation2Input) (*InputService24TestShapeInputService24TestCaseOperation2Output, error) { 4865 req, out := c.InputService24TestCaseOperation2Request(input) 4866 return out, req.Send() 4867} 4868 4869// InputService24TestCaseOperation2WithContext is the same as InputService24TestCaseOperation2 with the addition of 4870// the ability to pass a context and additional request options. 4871// 4872// See InputService24TestCaseOperation2 for details on how to use this API operation. 4873// 4874// The context must be non-nil and will be used for request cancellation. If 4875// the context is nil a panic will occur. In the future the SDK may create 4876// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 4877// for more information on using Contexts. 4878func (c *InputService24ProtocolTest) InputService24TestCaseOperation2WithContext(ctx aws.Context, input *InputService24TestShapeInputService24TestCaseOperation2Input, opts ...request.Option) (*InputService24TestShapeInputService24TestCaseOperation2Output, error) { 4879 req, out := c.InputService24TestCaseOperation2Request(input) 4880 req.SetContext(ctx) 4881 req.ApplyOptions(opts...) 4882 return out, req.Send() 4883} 4884 4885type InputService24TestShapeInputService24TestCaseOperation1Output struct { 4886 _ struct{} `type:"structure"` 4887} 4888 4889type InputService24TestShapeInputService24TestCaseOperation2Input struct { 4890 _ struct{} `type:"structure"` 4891 4892 Token *string `type:"string" idempotencyToken:"true"` 4893} 4894 4895// SetToken sets the Token field's value. 4896func (s *InputService24TestShapeInputService24TestCaseOperation2Input) SetToken(v string) *InputService24TestShapeInputService24TestCaseOperation2Input { 4897 s.Token = &v 4898 return s 4899} 4900 4901type InputService24TestShapeInputService24TestCaseOperation2Output struct { 4902 _ struct{} `type:"structure"` 4903} 4904 4905// 4906// Tests begin here 4907// 4908 4909func TestInputService1ProtocolTestBasicXMLSerializationCase1(t *testing.T) { 4910 svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 4911 input := &InputService1TestShapeInputService1TestCaseOperation2Input{ 4912 Description: aws.String("bar"), 4913 Name: aws.String("foo"), 4914 } 4915 req, _ := svc.InputService1TestCaseOperation1Request(input) 4916 r := req.HTTPRequest 4917 4918 // build request 4919 restxml.Build(req) 4920 if req.Error != nil { 4921 t.Errorf("expect no error, got %v", req.Error) 4922 } 4923 4924 // assert body 4925 if r.Body == nil { 4926 t.Errorf("expect body not to be nil") 4927 } 4928 body := util.SortXML(r.Body) 4929 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{}) 4930 4931 // assert URL 4932 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 4933 4934 // assert headers 4935 4936} 4937 4938func TestInputService1ProtocolTestBasicXMLSerializationCase2(t *testing.T) { 4939 svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 4940 input := &InputService1TestShapeInputService1TestCaseOperation2Input{ 4941 Description: aws.String("bar"), 4942 Name: aws.String("foo"), 4943 } 4944 req, _ := svc.InputService1TestCaseOperation2Request(input) 4945 r := req.HTTPRequest 4946 4947 // build request 4948 restxml.Build(req) 4949 if req.Error != nil { 4950 t.Errorf("expect no error, got %v", req.Error) 4951 } 4952 4953 // assert body 4954 if r.Body == nil { 4955 t.Errorf("expect body not to be nil") 4956 } 4957 body := util.SortXML(r.Body) 4958 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{}) 4959 4960 // assert URL 4961 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 4962 4963 // assert headers 4964 4965} 4966 4967func TestInputService1ProtocolTestBasicXMLSerializationCase3(t *testing.T) { 4968 svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 4969 input := &InputService1TestShapeInputService1TestCaseOperation3Input{} 4970 req, _ := svc.InputService1TestCaseOperation3Request(input) 4971 r := req.HTTPRequest 4972 4973 // build request 4974 restxml.Build(req) 4975 if req.Error != nil { 4976 t.Errorf("expect no error, got %v", req.Error) 4977 } 4978 4979 // assert URL 4980 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 4981 4982 // assert headers 4983 4984} 4985 4986func TestInputService2ProtocolTestSerializeOtherScalarTypesCase1(t *testing.T) { 4987 svc := NewInputService2ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 4988 input := &InputService2TestShapeInputService2TestCaseOperation1Input{ 4989 First: aws.Bool(true), 4990 Fourth: aws.Int64(3), 4991 Second: aws.Bool(false), 4992 Third: aws.Float64(1.2), 4993 } 4994 req, _ := svc.InputService2TestCaseOperation1Request(input) 4995 r := req.HTTPRequest 4996 4997 // build request 4998 restxml.Build(req) 4999 if req.Error != nil { 5000 t.Errorf("expect no error, got %v", req.Error) 5001 } 5002 5003 // assert body 5004 if r.Body == nil { 5005 t.Errorf("expect body not to be nil") 5006 } 5007 body := util.SortXML(r.Body) 5008 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{}) 5009 5010 // assert URL 5011 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 5012 5013 // assert headers 5014 5015} 5016 5017func TestInputService3ProtocolTestNestedStructuresCase1(t *testing.T) { 5018 svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5019 input := &InputService3TestShapeInputService3TestCaseOperation2Input{ 5020 Description: aws.String("baz"), 5021 SubStructure: &InputService3TestShapeSubStructure{ 5022 Bar: aws.String("b"), 5023 Foo: aws.String("a"), 5024 }, 5025 } 5026 req, _ := svc.InputService3TestCaseOperation1Request(input) 5027 r := req.HTTPRequest 5028 5029 // build request 5030 restxml.Build(req) 5031 if req.Error != nil { 5032 t.Errorf("expect no error, got %v", req.Error) 5033 } 5034 5035 // assert body 5036 if r.Body == nil { 5037 t.Errorf("expect body not to be nil") 5038 } 5039 body := util.SortXML(r.Body) 5040 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)), InputService3TestShapeInputService3TestCaseOperation2Input{}) 5041 5042 // assert URL 5043 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 5044 5045 // assert headers 5046 5047} 5048 5049func TestInputService3ProtocolTestNestedStructuresCase2(t *testing.T) { 5050 svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5051 input := &InputService3TestShapeInputService3TestCaseOperation2Input{ 5052 Description: aws.String("baz"), 5053 SubStructure: &InputService3TestShapeSubStructure{ 5054 Foo: aws.String("a"), 5055 }, 5056 } 5057 req, _ := svc.InputService3TestCaseOperation2Request(input) 5058 r := req.HTTPRequest 5059 5060 // build request 5061 restxml.Build(req) 5062 if req.Error != nil { 5063 t.Errorf("expect no error, got %v", req.Error) 5064 } 5065 5066 // assert body 5067 if r.Body == nil { 5068 t.Errorf("expect body not to be nil") 5069 } 5070 body := util.SortXML(r.Body) 5071 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{}) 5072 5073 // assert URL 5074 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 5075 5076 // assert headers 5077 5078} 5079 5080func TestInputService4ProtocolTestNestedStructuresCase1(t *testing.T) { 5081 svc := NewInputService4ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5082 input := &InputService4TestShapeInputService4TestCaseOperation1Input{ 5083 Description: aws.String("baz"), 5084 SubStructure: &InputService4TestShapeSubStructure{}, 5085 } 5086 req, _ := svc.InputService4TestCaseOperation1Request(input) 5087 r := req.HTTPRequest 5088 5089 // build request 5090 restxml.Build(req) 5091 if req.Error != nil { 5092 t.Errorf("expect no error, got %v", req.Error) 5093 } 5094 5095 // assert body 5096 if r.Body == nil { 5097 t.Errorf("expect body not to be nil") 5098 } 5099 body := util.SortXML(r.Body) 5100 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><Description xmlns="https://foo/">baz</Description><SubStructure xmlns="https://foo/"></SubStructure></OperationRequest>`, util.Trim(string(body)), InputService4TestShapeInputService4TestCaseOperation1Input{}) 5101 5102 // assert URL 5103 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 5104 5105 // assert headers 5106 5107} 5108 5109func TestInputService5ProtocolTestNonFlattenedListsCase1(t *testing.T) { 5110 svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5111 input := &InputService5TestShapeInputService5TestCaseOperation1Input{ 5112 ListParam: []*string{ 5113 aws.String("one"), 5114 aws.String("two"), 5115 aws.String("three"), 5116 }, 5117 } 5118 req, _ := svc.InputService5TestCaseOperation1Request(input) 5119 r := req.HTTPRequest 5120 5121 // build request 5122 restxml.Build(req) 5123 if req.Error != nil { 5124 t.Errorf("expect no error, got %v", req.Error) 5125 } 5126 5127 // assert body 5128 if r.Body == nil { 5129 t.Errorf("expect body not to be nil") 5130 } 5131 body := util.SortXML(r.Body) 5132 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{}) 5133 5134 // assert URL 5135 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 5136 5137 // assert headers 5138 5139} 5140 5141func TestInputService6ProtocolTestNonFlattenedListsWithLocationNameCase1(t *testing.T) { 5142 svc := NewInputService6ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5143 input := &InputService6TestShapeInputService6TestCaseOperation1Input{ 5144 ListParam: []*string{ 5145 aws.String("one"), 5146 aws.String("two"), 5147 aws.String("three"), 5148 }, 5149 } 5150 req, _ := svc.InputService6TestCaseOperation1Request(input) 5151 r := req.HTTPRequest 5152 5153 // build request 5154 restxml.Build(req) 5155 if req.Error != nil { 5156 t.Errorf("expect no error, got %v", req.Error) 5157 } 5158 5159 // assert body 5160 if r.Body == nil { 5161 t.Errorf("expect body not to be nil") 5162 } 5163 body := util.SortXML(r.Body) 5164 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{}) 5165 5166 // assert URL 5167 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 5168 5169 // assert headers 5170 5171} 5172 5173func TestInputService7ProtocolTestFlattenedListsCase1(t *testing.T) { 5174 svc := NewInputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5175 input := &InputService7TestShapeInputService7TestCaseOperation1Input{ 5176 ListParam: []*string{ 5177 aws.String("one"), 5178 aws.String("two"), 5179 aws.String("three"), 5180 }, 5181 } 5182 req, _ := svc.InputService7TestCaseOperation1Request(input) 5183 r := req.HTTPRequest 5184 5185 // build request 5186 restxml.Build(req) 5187 if req.Error != nil { 5188 t.Errorf("expect no error, got %v", req.Error) 5189 } 5190 5191 // assert body 5192 if r.Body == nil { 5193 t.Errorf("expect body not to be nil") 5194 } 5195 body := util.SortXML(r.Body) 5196 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{}) 5197 5198 // assert URL 5199 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 5200 5201 // assert headers 5202 5203} 5204 5205func TestInputService8ProtocolTestFlattenedListsWithLocationNameCase1(t *testing.T) { 5206 svc := NewInputService8ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5207 input := &InputService8TestShapeInputService8TestCaseOperation1Input{ 5208 ListParam: []*string{ 5209 aws.String("one"), 5210 aws.String("two"), 5211 aws.String("three"), 5212 }, 5213 } 5214 req, _ := svc.InputService8TestCaseOperation1Request(input) 5215 r := req.HTTPRequest 5216 5217 // build request 5218 restxml.Build(req) 5219 if req.Error != nil { 5220 t.Errorf("expect no error, got %v", req.Error) 5221 } 5222 5223 // assert body 5224 if r.Body == nil { 5225 t.Errorf("expect body not to be nil") 5226 } 5227 body := util.SortXML(r.Body) 5228 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{}) 5229 5230 // assert URL 5231 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 5232 5233 // assert headers 5234 5235} 5236 5237func TestInputService9ProtocolTestListOfStructuresCase1(t *testing.T) { 5238 svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5239 input := &InputService9TestShapeInputService9TestCaseOperation1Input{ 5240 ListParam: []*InputService9TestShapeSingleFieldStruct{ 5241 { 5242 Element: aws.String("one"), 5243 }, 5244 { 5245 Element: aws.String("two"), 5246 }, 5247 { 5248 Element: aws.String("three"), 5249 }, 5250 }, 5251 } 5252 req, _ := svc.InputService9TestCaseOperation1Request(input) 5253 r := req.HTTPRequest 5254 5255 // build request 5256 restxml.Build(req) 5257 if req.Error != nil { 5258 t.Errorf("expect no error, got %v", req.Error) 5259 } 5260 5261 // assert body 5262 if r.Body == nil { 5263 t.Errorf("expect body not to be nil") 5264 } 5265 body := util.SortXML(r.Body) 5266 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{}) 5267 5268 // assert URL 5269 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 5270 5271 // assert headers 5272 5273} 5274 5275func TestInputService10ProtocolTestBlobAndTimestampShapesCase1(t *testing.T) { 5276 svc := NewInputService10ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5277 input := &InputService10TestShapeInputService10TestCaseOperation1Input{ 5278 StructureParam: &InputService10TestShapeStructureShape{ 5279 B: []byte("foo"), 5280 T: aws.Time(time.Unix(1422172800, 0)), 5281 }, 5282 } 5283 req, _ := svc.InputService10TestCaseOperation1Request(input) 5284 r := req.HTTPRequest 5285 5286 // build request 5287 restxml.Build(req) 5288 if req.Error != nil { 5289 t.Errorf("expect no error, got %v", req.Error) 5290 } 5291 5292 // assert body 5293 if r.Body == nil { 5294 t.Errorf("expect body not to be nil") 5295 } 5296 body := util.SortXML(r.Body) 5297 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><StructureParam xmlns="https://foo/"><b xmlns="https://foo/">Zm9v</b><t xmlns="https://foo/">2015-01-25T08:00:00Z</t></StructureParam></OperationRequest>`, util.Trim(string(body)), InputService10TestShapeInputService10TestCaseOperation1Input{}) 5298 5299 // assert URL 5300 awstesting.AssertURL(t, "https://test/2014-01-01/hostedzone", r.URL.String()) 5301 5302 // assert headers 5303 5304} 5305 5306func TestInputService11ProtocolTestHeaderMapsCase1(t *testing.T) { 5307 svc := NewInputService11ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5308 input := &InputService11TestShapeInputService11TestCaseOperation1Input{ 5309 Foo: map[string]*string{ 5310 "a": aws.String("b"), 5311 "c": aws.String("d"), 5312 }, 5313 } 5314 req, _ := svc.InputService11TestCaseOperation1Request(input) 5315 r := req.HTTPRequest 5316 5317 // build request 5318 restxml.Build(req) 5319 if req.Error != nil { 5320 t.Errorf("expect no error, got %v", req.Error) 5321 } 5322 5323 // assert URL 5324 awstesting.AssertURL(t, "https://test/", r.URL.String()) 5325 5326 // assert headers 5327 if e, a := "b", r.Header.Get("x-foo-a"); e != a { 5328 t.Errorf("expect %v to be %v", e, a) 5329 } 5330 if e, a := "d", r.Header.Get("x-foo-c"); e != a { 5331 t.Errorf("expect %v to be %v", e, a) 5332 } 5333 5334} 5335 5336func TestInputService12ProtocolTestQuerystringListOfStringsCase1(t *testing.T) { 5337 svc := NewInputService12ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5338 input := &InputService12TestShapeInputService12TestCaseOperation1Input{ 5339 Items: []*string{ 5340 aws.String("value1"), 5341 aws.String("value2"), 5342 }, 5343 } 5344 req, _ := svc.InputService12TestCaseOperation1Request(input) 5345 r := req.HTTPRequest 5346 5347 // build request 5348 restxml.Build(req) 5349 if req.Error != nil { 5350 t.Errorf("expect no error, got %v", req.Error) 5351 } 5352 5353 // assert URL 5354 awstesting.AssertURL(t, "https://test/path?item=value1&item=value2", r.URL.String()) 5355 5356 // assert headers 5357 5358} 5359 5360func TestInputService13ProtocolTestStringToStringMapsInQuerystringCase1(t *testing.T) { 5361 svc := NewInputService13ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5362 input := &InputService13TestShapeInputService13TestCaseOperation1Input{ 5363 PipelineId: aws.String("foo"), 5364 QueryDoc: map[string]*string{ 5365 "bar": aws.String("baz"), 5366 "fizz": aws.String("buzz"), 5367 }, 5368 } 5369 req, _ := svc.InputService13TestCaseOperation1Request(input) 5370 r := req.HTTPRequest 5371 5372 // build request 5373 restxml.Build(req) 5374 if req.Error != nil { 5375 t.Errorf("expect no error, got %v", req.Error) 5376 } 5377 5378 // assert URL 5379 awstesting.AssertURL(t, "https://test/2014-01-01/jobsByPipeline/foo?bar=baz&fizz=buzz", r.URL.String()) 5380 5381 // assert headers 5382 5383} 5384 5385func TestInputService14ProtocolTestStringToStringListMapsInQuerystringCase1(t *testing.T) { 5386 svc := NewInputService14ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5387 input := &InputService14TestShapeInputService14TestCaseOperation1Input{ 5388 PipelineId: aws.String("id"), 5389 QueryDoc: map[string][]*string{ 5390 "fizz": { 5391 aws.String("buzz"), 5392 aws.String("pop"), 5393 }, 5394 "foo": { 5395 aws.String("bar"), 5396 aws.String("baz"), 5397 }, 5398 }, 5399 } 5400 req, _ := svc.InputService14TestCaseOperation1Request(input) 5401 r := req.HTTPRequest 5402 5403 // build request 5404 restxml.Build(req) 5405 if req.Error != nil { 5406 t.Errorf("expect no error, got %v", req.Error) 5407 } 5408 5409 // assert URL 5410 awstesting.AssertURL(t, "https://test/2014-01-01/jobsByPipeline/id?foo=bar&foo=baz&fizz=buzz&fizz=pop", r.URL.String()) 5411 5412 // assert headers 5413 5414} 5415 5416func TestInputService15ProtocolTestBooleanInQuerystringCase1(t *testing.T) { 5417 svc := NewInputService15ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5418 input := &InputService15TestShapeInputService15TestCaseOperation2Input{ 5419 BoolQuery: aws.Bool(true), 5420 } 5421 req, _ := svc.InputService15TestCaseOperation1Request(input) 5422 r := req.HTTPRequest 5423 5424 // build request 5425 restxml.Build(req) 5426 if req.Error != nil { 5427 t.Errorf("expect no error, got %v", req.Error) 5428 } 5429 5430 // assert URL 5431 awstesting.AssertURL(t, "https://test/path?bool-query=true", r.URL.String()) 5432 5433 // assert headers 5434 5435} 5436 5437func TestInputService15ProtocolTestBooleanInQuerystringCase2(t *testing.T) { 5438 svc := NewInputService15ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5439 input := &InputService15TestShapeInputService15TestCaseOperation2Input{ 5440 BoolQuery: aws.Bool(false), 5441 } 5442 req, _ := svc.InputService15TestCaseOperation2Request(input) 5443 r := req.HTTPRequest 5444 5445 // build request 5446 restxml.Build(req) 5447 if req.Error != nil { 5448 t.Errorf("expect no error, got %v", req.Error) 5449 } 5450 5451 // assert URL 5452 awstesting.AssertURL(t, "https://test/path?bool-query=false", r.URL.String()) 5453 5454 // assert headers 5455 5456} 5457 5458func TestInputService16ProtocolTestStringPayloadCase1(t *testing.T) { 5459 svc := NewInputService16ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5460 input := &InputService16TestShapeInputService16TestCaseOperation1Input{ 5461 Foo: aws.String("bar"), 5462 } 5463 req, _ := svc.InputService16TestCaseOperation1Request(input) 5464 r := req.HTTPRequest 5465 5466 // build request 5467 restxml.Build(req) 5468 if req.Error != nil { 5469 t.Errorf("expect no error, got %v", req.Error) 5470 } 5471 5472 // assert body 5473 if r.Body == nil { 5474 t.Errorf("expect body not to be nil") 5475 } 5476 body := util.SortXML(r.Body) 5477 if e, a := "bar", util.Trim(string(body)); e != a { 5478 t.Errorf("expect %v, got %v", e, a) 5479 } 5480 5481 // assert URL 5482 awstesting.AssertURL(t, "https://test/", r.URL.String()) 5483 5484 // assert headers 5485 5486} 5487 5488func TestInputService17ProtocolTestBlobPayloadCase1(t *testing.T) { 5489 svc := NewInputService17ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5490 input := &InputService17TestShapeInputService17TestCaseOperation2Input{ 5491 Foo: []byte("bar"), 5492 } 5493 req, _ := svc.InputService17TestCaseOperation1Request(input) 5494 r := req.HTTPRequest 5495 5496 // build request 5497 restxml.Build(req) 5498 if req.Error != nil { 5499 t.Errorf("expect no error, got %v", req.Error) 5500 } 5501 5502 // assert body 5503 if r.Body == nil { 5504 t.Errorf("expect body not to be nil") 5505 } 5506 body := util.SortXML(r.Body) 5507 if e, a := "bar", util.Trim(string(body)); e != a { 5508 t.Errorf("expect %v, got %v", e, a) 5509 } 5510 5511 // assert URL 5512 awstesting.AssertURL(t, "https://test/", r.URL.String()) 5513 5514 // assert headers 5515 5516} 5517 5518func TestInputService17ProtocolTestBlobPayloadCase2(t *testing.T) { 5519 svc := NewInputService17ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5520 input := &InputService17TestShapeInputService17TestCaseOperation2Input{} 5521 req, _ := svc.InputService17TestCaseOperation2Request(input) 5522 r := req.HTTPRequest 5523 5524 // build request 5525 restxml.Build(req) 5526 if req.Error != nil { 5527 t.Errorf("expect no error, got %v", req.Error) 5528 } 5529 5530 // assert URL 5531 awstesting.AssertURL(t, "https://test/", r.URL.String()) 5532 5533 // assert headers 5534 5535} 5536 5537func TestInputService18ProtocolTestStructurePayloadCase1(t *testing.T) { 5538 svc := NewInputService18ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5539 input := &InputService18TestShapeInputService18TestCaseOperation4Input{ 5540 Foo: &InputService18TestShapeFooShape{ 5541 Baz: aws.String("bar"), 5542 }, 5543 } 5544 req, _ := svc.InputService18TestCaseOperation1Request(input) 5545 r := req.HTTPRequest 5546 5547 // build request 5548 restxml.Build(req) 5549 if req.Error != nil { 5550 t.Errorf("expect no error, got %v", req.Error) 5551 } 5552 5553 // assert body 5554 if r.Body == nil { 5555 t.Errorf("expect body not to be nil") 5556 } 5557 body := util.SortXML(r.Body) 5558 awstesting.AssertXML(t, `<foo><baz>bar</baz></foo>`, util.Trim(string(body)), InputService18TestShapeInputService18TestCaseOperation4Input{}) 5559 5560 // assert URL 5561 awstesting.AssertURL(t, "https://test/", r.URL.String()) 5562 5563 // assert headers 5564 5565} 5566 5567func TestInputService18ProtocolTestStructurePayloadCase2(t *testing.T) { 5568 svc := NewInputService18ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5569 input := &InputService18TestShapeInputService18TestCaseOperation4Input{} 5570 req, _ := svc.InputService18TestCaseOperation2Request(input) 5571 r := req.HTTPRequest 5572 5573 // build request 5574 restxml.Build(req) 5575 if req.Error != nil { 5576 t.Errorf("expect no error, got %v", req.Error) 5577 } 5578 5579 // assert URL 5580 awstesting.AssertURL(t, "https://test/", r.URL.String()) 5581 5582 // assert headers 5583 5584} 5585 5586func TestInputService18ProtocolTestStructurePayloadCase3(t *testing.T) { 5587 svc := NewInputService18ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5588 input := &InputService18TestShapeInputService18TestCaseOperation4Input{ 5589 Foo: &InputService18TestShapeFooShape{}, 5590 } 5591 req, _ := svc.InputService18TestCaseOperation3Request(input) 5592 r := req.HTTPRequest 5593 5594 // build request 5595 restxml.Build(req) 5596 if req.Error != nil { 5597 t.Errorf("expect no error, got %v", req.Error) 5598 } 5599 5600 // assert body 5601 if r.Body == nil { 5602 t.Errorf("expect body not to be nil") 5603 } 5604 body := util.SortXML(r.Body) 5605 awstesting.AssertXML(t, `<foo></foo>`, util.Trim(string(body)), InputService18TestShapeInputService18TestCaseOperation4Input{}) 5606 5607 // assert URL 5608 awstesting.AssertURL(t, "https://test/", r.URL.String()) 5609 5610 // assert headers 5611 5612} 5613 5614func TestInputService18ProtocolTestStructurePayloadCase4(t *testing.T) { 5615 svc := NewInputService18ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5616 input := &InputService18TestShapeInputService18TestCaseOperation4Input{} 5617 req, _ := svc.InputService18TestCaseOperation4Request(input) 5618 r := req.HTTPRequest 5619 5620 // build request 5621 restxml.Build(req) 5622 if req.Error != nil { 5623 t.Errorf("expect no error, got %v", req.Error) 5624 } 5625 5626 // assert URL 5627 awstesting.AssertURL(t, "https://test/", r.URL.String()) 5628 5629 // assert headers 5630 5631} 5632 5633func TestInputService19ProtocolTestXMLAttributeCase1(t *testing.T) { 5634 svc := NewInputService19ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5635 input := &InputService19TestShapeInputService19TestCaseOperation1Input{ 5636 Grant: &InputService19TestShapeGrant{ 5637 Grantee: &InputService19TestShapeGrantee{ 5638 EmailAddress: aws.String("foo@example.com"), 5639 Type: aws.String("CanonicalUser"), 5640 }, 5641 }, 5642 } 5643 req, _ := svc.InputService19TestCaseOperation1Request(input) 5644 r := req.HTTPRequest 5645 5646 // build request 5647 restxml.Build(req) 5648 if req.Error != nil { 5649 t.Errorf("expect no error, got %v", req.Error) 5650 } 5651 5652 // assert body 5653 if r.Body == nil { 5654 t.Errorf("expect body not to be nil") 5655 } 5656 body := util.SortXML(r.Body) 5657 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)), InputService19TestShapeInputService19TestCaseOperation1Input{}) 5658 5659 // assert URL 5660 awstesting.AssertURL(t, "https://test/", r.URL.String()) 5661 5662 // assert headers 5663 5664} 5665 5666func TestInputService20ProtocolTestGreedyKeysCase1(t *testing.T) { 5667 svc := NewInputService20ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5668 input := &InputService20TestShapeInputService20TestCaseOperation1Input{ 5669 Bucket: aws.String("my/bucket"), 5670 Key: aws.String("testing /123"), 5671 } 5672 req, _ := svc.InputService20TestCaseOperation1Request(input) 5673 r := req.HTTPRequest 5674 5675 // build request 5676 restxml.Build(req) 5677 if req.Error != nil { 5678 t.Errorf("expect no error, got %v", req.Error) 5679 } 5680 5681 // assert URL 5682 awstesting.AssertURL(t, "https://test/my%2Fbucket/testing%20/123", r.URL.String()) 5683 5684 // assert headers 5685 5686} 5687 5688func TestInputService21ProtocolTestOmitsNullQueryParamsButSerializesEmptyStringsCase1(t *testing.T) { 5689 svc := NewInputService21ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5690 input := &InputService21TestShapeInputService21TestCaseOperation2Input{} 5691 req, _ := svc.InputService21TestCaseOperation1Request(input) 5692 r := req.HTTPRequest 5693 5694 // build request 5695 restxml.Build(req) 5696 if req.Error != nil { 5697 t.Errorf("expect no error, got %v", req.Error) 5698 } 5699 5700 // assert URL 5701 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 5702 5703 // assert headers 5704 5705} 5706 5707func TestInputService21ProtocolTestOmitsNullQueryParamsButSerializesEmptyStringsCase2(t *testing.T) { 5708 svc := NewInputService21ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5709 input := &InputService21TestShapeInputService21TestCaseOperation2Input{ 5710 Foo: aws.String(""), 5711 } 5712 req, _ := svc.InputService21TestCaseOperation2Request(input) 5713 r := req.HTTPRequest 5714 5715 // build request 5716 restxml.Build(req) 5717 if req.Error != nil { 5718 t.Errorf("expect no error, got %v", req.Error) 5719 } 5720 5721 // assert URL 5722 awstesting.AssertURL(t, "https://test/path?abc=mno¶m-name=", r.URL.String()) 5723 5724 // assert headers 5725 5726} 5727 5728func TestInputService22ProtocolTestRecursiveShapesCase1(t *testing.T) { 5729 svc := NewInputService22ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5730 input := &InputService22TestShapeInputService22TestCaseOperation6Input{ 5731 RecursiveStruct: &InputService22TestShapeRecursiveStructType{ 5732 NoRecurse: aws.String("foo"), 5733 }, 5734 } 5735 req, _ := svc.InputService22TestCaseOperation1Request(input) 5736 r := req.HTTPRequest 5737 5738 // build request 5739 restxml.Build(req) 5740 if req.Error != nil { 5741 t.Errorf("expect no error, got %v", req.Error) 5742 } 5743 5744 // assert body 5745 if r.Body == nil { 5746 t.Errorf("expect body not to be nil") 5747 } 5748 body := util.SortXML(r.Body) 5749 awstesting.AssertXML(t, `<OperationRequest xmlns="https://foo/"><RecursiveStruct xmlns="https://foo/"><NoRecurse xmlns="https://foo/">foo</NoRecurse></RecursiveStruct></OperationRequest>`, util.Trim(string(body)), InputService22TestShapeInputService22TestCaseOperation6Input{}) 5750 5751 // assert URL 5752 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 5753 5754 // assert headers 5755 5756} 5757 5758func TestInputService22ProtocolTestRecursiveShapesCase2(t *testing.T) { 5759 svc := NewInputService22ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5760 input := &InputService22TestShapeInputService22TestCaseOperation6Input{ 5761 RecursiveStruct: &InputService22TestShapeRecursiveStructType{ 5762 RecursiveStruct: &InputService22TestShapeRecursiveStructType{ 5763 NoRecurse: aws.String("foo"), 5764 }, 5765 }, 5766 } 5767 req, _ := svc.InputService22TestCaseOperation2Request(input) 5768 r := req.HTTPRequest 5769 5770 // build request 5771 restxml.Build(req) 5772 if req.Error != nil { 5773 t.Errorf("expect no error, got %v", req.Error) 5774 } 5775 5776 // assert body 5777 if r.Body == nil { 5778 t.Errorf("expect body not to be nil") 5779 } 5780 body := util.SortXML(r.Body) 5781 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)), InputService22TestShapeInputService22TestCaseOperation6Input{}) 5782 5783 // assert URL 5784 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 5785 5786 // assert headers 5787 5788} 5789 5790func TestInputService22ProtocolTestRecursiveShapesCase3(t *testing.T) { 5791 svc := NewInputService22ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5792 input := &InputService22TestShapeInputService22TestCaseOperation6Input{ 5793 RecursiveStruct: &InputService22TestShapeRecursiveStructType{ 5794 RecursiveStruct: &InputService22TestShapeRecursiveStructType{ 5795 RecursiveStruct: &InputService22TestShapeRecursiveStructType{ 5796 RecursiveStruct: &InputService22TestShapeRecursiveStructType{ 5797 NoRecurse: aws.String("foo"), 5798 }, 5799 }, 5800 }, 5801 }, 5802 } 5803 req, _ := svc.InputService22TestCaseOperation3Request(input) 5804 r := req.HTTPRequest 5805 5806 // build request 5807 restxml.Build(req) 5808 if req.Error != nil { 5809 t.Errorf("expect no error, got %v", req.Error) 5810 } 5811 5812 // assert body 5813 if r.Body == nil { 5814 t.Errorf("expect body not to be nil") 5815 } 5816 body := util.SortXML(r.Body) 5817 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)), InputService22TestShapeInputService22TestCaseOperation6Input{}) 5818 5819 // assert URL 5820 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 5821 5822 // assert headers 5823 5824} 5825 5826func TestInputService22ProtocolTestRecursiveShapesCase4(t *testing.T) { 5827 svc := NewInputService22ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5828 input := &InputService22TestShapeInputService22TestCaseOperation6Input{ 5829 RecursiveStruct: &InputService22TestShapeRecursiveStructType{ 5830 RecursiveList: []*InputService22TestShapeRecursiveStructType{ 5831 { 5832 NoRecurse: aws.String("foo"), 5833 }, 5834 { 5835 NoRecurse: aws.String("bar"), 5836 }, 5837 }, 5838 }, 5839 } 5840 req, _ := svc.InputService22TestCaseOperation4Request(input) 5841 r := req.HTTPRequest 5842 5843 // build request 5844 restxml.Build(req) 5845 if req.Error != nil { 5846 t.Errorf("expect no error, got %v", req.Error) 5847 } 5848 5849 // assert body 5850 if r.Body == nil { 5851 t.Errorf("expect body not to be nil") 5852 } 5853 body := util.SortXML(r.Body) 5854 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)), InputService22TestShapeInputService22TestCaseOperation6Input{}) 5855 5856 // assert URL 5857 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 5858 5859 // assert headers 5860 5861} 5862 5863func TestInputService22ProtocolTestRecursiveShapesCase5(t *testing.T) { 5864 svc := NewInputService22ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5865 input := &InputService22TestShapeInputService22TestCaseOperation6Input{ 5866 RecursiveStruct: &InputService22TestShapeRecursiveStructType{ 5867 RecursiveList: []*InputService22TestShapeRecursiveStructType{ 5868 { 5869 NoRecurse: aws.String("foo"), 5870 }, 5871 { 5872 RecursiveStruct: &InputService22TestShapeRecursiveStructType{ 5873 NoRecurse: aws.String("bar"), 5874 }, 5875 }, 5876 }, 5877 }, 5878 } 5879 req, _ := svc.InputService22TestCaseOperation5Request(input) 5880 r := req.HTTPRequest 5881 5882 // build request 5883 restxml.Build(req) 5884 if req.Error != nil { 5885 t.Errorf("expect no error, got %v", req.Error) 5886 } 5887 5888 // assert body 5889 if r.Body == nil { 5890 t.Errorf("expect body not to be nil") 5891 } 5892 body := util.SortXML(r.Body) 5893 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)), InputService22TestShapeInputService22TestCaseOperation6Input{}) 5894 5895 // assert URL 5896 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 5897 5898 // assert headers 5899 5900} 5901 5902func TestInputService22ProtocolTestRecursiveShapesCase6(t *testing.T) { 5903 svc := NewInputService22ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5904 input := &InputService22TestShapeInputService22TestCaseOperation6Input{ 5905 RecursiveStruct: &InputService22TestShapeRecursiveStructType{ 5906 RecursiveMap: map[string]*InputService22TestShapeRecursiveStructType{ 5907 "bar": { 5908 NoRecurse: aws.String("bar"), 5909 }, 5910 "foo": { 5911 NoRecurse: aws.String("foo"), 5912 }, 5913 }, 5914 }, 5915 } 5916 req, _ := svc.InputService22TestCaseOperation6Request(input) 5917 r := req.HTTPRequest 5918 5919 // build request 5920 restxml.Build(req) 5921 if req.Error != nil { 5922 t.Errorf("expect no error, got %v", req.Error) 5923 } 5924 5925 // assert body 5926 if r.Body == nil { 5927 t.Errorf("expect body not to be nil") 5928 } 5929 body := util.SortXML(r.Body) 5930 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)), InputService22TestShapeInputService22TestCaseOperation6Input{}) 5931 5932 // assert URL 5933 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 5934 5935 // assert headers 5936 5937} 5938 5939func TestInputService23ProtocolTestTimestampInHeaderCase1(t *testing.T) { 5940 svc := NewInputService23ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5941 input := &InputService23TestShapeInputService23TestCaseOperation1Input{ 5942 TimeArgInHeader: aws.Time(time.Unix(1422172800, 0)), 5943 } 5944 req, _ := svc.InputService23TestCaseOperation1Request(input) 5945 r := req.HTTPRequest 5946 5947 // build request 5948 restxml.Build(req) 5949 if req.Error != nil { 5950 t.Errorf("expect no error, got %v", req.Error) 5951 } 5952 5953 // assert URL 5954 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 5955 5956 // assert headers 5957 if e, a := "Sun, 25 Jan 2015 08:00:00 GMT", r.Header.Get("x-amz-timearg"); e != a { 5958 t.Errorf("expect %v to be %v", e, a) 5959 } 5960 5961} 5962 5963func TestInputService24ProtocolTestIdempotencyTokenAutoFillCase1(t *testing.T) { 5964 svc := NewInputService24ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5965 input := &InputService24TestShapeInputService24TestCaseOperation2Input{ 5966 Token: aws.String("abc123"), 5967 } 5968 req, _ := svc.InputService24TestCaseOperation1Request(input) 5969 r := req.HTTPRequest 5970 5971 // build request 5972 restxml.Build(req) 5973 if req.Error != nil { 5974 t.Errorf("expect no error, got %v", req.Error) 5975 } 5976 5977 // assert body 5978 if r.Body == nil { 5979 t.Errorf("expect body not to be nil") 5980 } 5981 body := util.SortXML(r.Body) 5982 awstesting.AssertXML(t, `<InputShape><Token>abc123</Token></InputShape>`, util.Trim(string(body)), InputService24TestShapeInputService24TestCaseOperation2Input{}) 5983 5984 // assert URL 5985 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 5986 5987 // assert headers 5988 5989} 5990 5991func TestInputService24ProtocolTestIdempotencyTokenAutoFillCase2(t *testing.T) { 5992 svc := NewInputService24ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 5993 input := &InputService24TestShapeInputService24TestCaseOperation2Input{} 5994 req, _ := svc.InputService24TestCaseOperation2Request(input) 5995 r := req.HTTPRequest 5996 5997 // build request 5998 restxml.Build(req) 5999 if req.Error != nil { 6000 t.Errorf("expect no error, got %v", req.Error) 6001 } 6002 6003 // assert body 6004 if r.Body == nil { 6005 t.Errorf("expect body not to be nil") 6006 } 6007 body := util.SortXML(r.Body) 6008 awstesting.AssertXML(t, `<InputShape><Token>00000000-0000-4000-8000-000000000000</Token></InputShape>`, util.Trim(string(body)), InputService24TestShapeInputService24TestCaseOperation2Input{}) 6009 6010 // assert URL 6011 awstesting.AssertURL(t, "https://test/path", r.URL.String()) 6012 6013 // assert headers 6014 6015} 6016