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