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