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