1package ec2query_test 2 3import ( 4 "bytes" 5 "encoding/json" 6 "encoding/xml" 7 "fmt" 8 "io" 9 "io/ioutil" 10 "net/http" 11 "net/url" 12 "reflect" 13 "testing" 14 "time" 15 16 "github.com/aws/aws-sdk-go/aws" 17 "github.com/aws/aws-sdk-go/aws/client" 18 "github.com/aws/aws-sdk-go/aws/client/metadata" 19 "github.com/aws/aws-sdk-go/aws/request" 20 "github.com/aws/aws-sdk-go/aws/signer/v4" 21 "github.com/aws/aws-sdk-go/awstesting" 22 "github.com/aws/aws-sdk-go/awstesting/unit" 23 "github.com/aws/aws-sdk-go/private/protocol" 24 "github.com/aws/aws-sdk-go/private/protocol/ec2query" 25 "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil" 26 "github.com/aws/aws-sdk-go/private/util" 27) 28 29var _ bytes.Buffer // always import bytes 30var _ http.Request 31var _ json.Marshaler 32var _ time.Time 33var _ xmlutil.XMLNode 34var _ xml.Attr 35var _ = ioutil.Discard 36var _ = util.Trim("") 37var _ = url.Values{} 38var _ = io.EOF 39var _ = aws.String 40var _ = fmt.Println 41var _ = reflect.Value{} 42 43func init() { 44 protocol.RandReader = &awstesting.ZeroReader{} 45} 46 47// InputService1ProtocolTest provides the API operation methods for making requests to 48// . See this package's package overview docs 49// for details on the service. 50// 51// InputService1ProtocolTest methods are safe to use concurrently. It is not safe to 52// modify mutate any of the struct's properties though. 53type InputService1ProtocolTest struct { 54 *client.Client 55} 56 57// New creates a new instance of the InputService1ProtocolTest client with a session. 58// If additional configuration is needed for the client instance use the optional 59// aws.Config parameter to add your extra config. 60// 61// Example: 62// // Create a InputService1ProtocolTest client from just a session. 63// svc := inputservice1protocoltest.New(mySession) 64// 65// // Create a InputService1ProtocolTest client with additional configuration 66// svc := inputservice1protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 67func NewInputService1ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService1ProtocolTest { 68 c := p.ClientConfig("inputservice1protocoltest", cfgs...) 69 return newInputService1ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 70} 71 72// newClient creates, initializes and returns a new service client instance. 73func newInputService1ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService1ProtocolTest { 74 svc := &InputService1ProtocolTest{ 75 Client: client.New( 76 cfg, 77 metadata.ClientInfo{ 78 ServiceName: "InputService1ProtocolTest", 79 ServiceID: "InputService1ProtocolTest", 80 SigningName: signingName, 81 SigningRegion: signingRegion, 82 Endpoint: endpoint, 83 APIVersion: "2014-01-01", 84 }, 85 handlers, 86 ), 87 } 88 89 // Handlers 90 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 91 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 92 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 93 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 94 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 95 96 return svc 97} 98 99// newRequest creates a new request for a InputService1ProtocolTest operation and runs any 100// custom request initialization. 101func (c *InputService1ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 102 req := c.NewRequest(op, params, data) 103 104 return req 105} 106 107const opInputService1TestCaseOperation1 = "OperationName" 108 109// InputService1TestCaseOperation1Request generates a "aws/request.Request" representing the 110// client's request for the InputService1TestCaseOperation1 operation. The "output" return 111// value will be populated with the request's response once the request completes 112// successfuly. 113// 114// Use "Send" method on the returned Request to send the API call to the service. 115// the "output" return value is not valid until after Send returns without error. 116// 117// See InputService1TestCaseOperation1 for more information on using the InputService1TestCaseOperation1 118// API call, and error handling. 119// 120// This method is useful when you want to inject custom logic or configuration 121// into the SDK's request lifecycle. Such as custom headers, or retry logic. 122// 123// 124// // Example sending a request using the InputService1TestCaseOperation1Request method. 125// req, resp := client.InputService1TestCaseOperation1Request(params) 126// 127// err := req.Send() 128// if err == nil { // resp is now filled 129// fmt.Println(resp) 130// } 131func (c *InputService1ProtocolTest) InputService1TestCaseOperation1Request(input *InputService1TestShapeInputService1TestCaseOperation1Input) (req *request.Request, output *InputService1TestShapeInputService1TestCaseOperation1Output) { 132 op := &request.Operation{ 133 Name: opInputService1TestCaseOperation1, 134 HTTPPath: "/", 135 } 136 137 if input == nil { 138 input = &InputService1TestShapeInputService1TestCaseOperation1Input{} 139 } 140 141 output = &InputService1TestShapeInputService1TestCaseOperation1Output{} 142 req = c.newRequest(op, input, output) 143 req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler) 144 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 145 return 146} 147 148// InputService1TestCaseOperation1 API operation for . 149// 150// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 151// with awserr.Error's Code and Message methods to get detailed information about 152// the error. 153// 154// See the AWS API reference guide for 's 155// API operation InputService1TestCaseOperation1 for usage and error information. 156func (c *InputService1ProtocolTest) InputService1TestCaseOperation1(input *InputService1TestShapeInputService1TestCaseOperation1Input) (*InputService1TestShapeInputService1TestCaseOperation1Output, error) { 157 req, out := c.InputService1TestCaseOperation1Request(input) 158 return out, req.Send() 159} 160 161// InputService1TestCaseOperation1WithContext is the same as InputService1TestCaseOperation1 with the addition of 162// the ability to pass a context and additional request options. 163// 164// See InputService1TestCaseOperation1 for details on how to use this API operation. 165// 166// The context must be non-nil and will be used for request cancellation. If 167// the context is nil a panic will occur. In the future the SDK may create 168// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 169// for more information on using Contexts. 170func (c *InputService1ProtocolTest) InputService1TestCaseOperation1WithContext(ctx aws.Context, input *InputService1TestShapeInputService1TestCaseOperation1Input, opts ...request.Option) (*InputService1TestShapeInputService1TestCaseOperation1Output, error) { 171 req, out := c.InputService1TestCaseOperation1Request(input) 172 req.SetContext(ctx) 173 req.ApplyOptions(opts...) 174 return out, req.Send() 175} 176 177type InputService1TestShapeInputService1TestCaseOperation1Input struct { 178 _ struct{} `type:"structure"` 179 180 Bar *string `type:"string"` 181 182 Foo *string `type:"string"` 183} 184 185// SetBar sets the Bar field's value. 186func (s *InputService1TestShapeInputService1TestCaseOperation1Input) SetBar(v string) *InputService1TestShapeInputService1TestCaseOperation1Input { 187 s.Bar = &v 188 return s 189} 190 191// SetFoo sets the Foo field's value. 192func (s *InputService1TestShapeInputService1TestCaseOperation1Input) SetFoo(v string) *InputService1TestShapeInputService1TestCaseOperation1Input { 193 s.Foo = &v 194 return s 195} 196 197type InputService1TestShapeInputService1TestCaseOperation1Output struct { 198 _ struct{} `type:"structure"` 199} 200 201// InputService2ProtocolTest provides the API operation methods for making requests to 202// . See this package's package overview docs 203// for details on the service. 204// 205// InputService2ProtocolTest methods are safe to use concurrently. It is not safe to 206// modify mutate any of the struct's properties though. 207type InputService2ProtocolTest struct { 208 *client.Client 209} 210 211// New creates a new instance of the InputService2ProtocolTest client with a session. 212// If additional configuration is needed for the client instance use the optional 213// aws.Config parameter to add your extra config. 214// 215// Example: 216// // Create a InputService2ProtocolTest client from just a session. 217// svc := inputservice2protocoltest.New(mySession) 218// 219// // Create a InputService2ProtocolTest client with additional configuration 220// svc := inputservice2protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 221func NewInputService2ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService2ProtocolTest { 222 c := p.ClientConfig("inputservice2protocoltest", cfgs...) 223 return newInputService2ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 224} 225 226// newClient creates, initializes and returns a new service client instance. 227func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService2ProtocolTest { 228 svc := &InputService2ProtocolTest{ 229 Client: client.New( 230 cfg, 231 metadata.ClientInfo{ 232 ServiceName: "InputService2ProtocolTest", 233 ServiceID: "InputService2ProtocolTest", 234 SigningName: signingName, 235 SigningRegion: signingRegion, 236 Endpoint: endpoint, 237 APIVersion: "2014-01-01", 238 }, 239 handlers, 240 ), 241 } 242 243 // Handlers 244 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 245 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 246 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 247 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 248 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 249 250 return svc 251} 252 253// newRequest creates a new request for a InputService2ProtocolTest operation and runs any 254// custom request initialization. 255func (c *InputService2ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 256 req := c.NewRequest(op, params, data) 257 258 return req 259} 260 261const opInputService2TestCaseOperation1 = "OperationName" 262 263// InputService2TestCaseOperation1Request generates a "aws/request.Request" representing the 264// client's request for the InputService2TestCaseOperation1 operation. The "output" return 265// value will be populated with the request's response once the request completes 266// successfuly. 267// 268// Use "Send" method on the returned Request to send the API call to the service. 269// the "output" return value is not valid until after Send returns without error. 270// 271// See InputService2TestCaseOperation1 for more information on using the InputService2TestCaseOperation1 272// API call, and error handling. 273// 274// This method is useful when you want to inject custom logic or configuration 275// into the SDK's request lifecycle. Such as custom headers, or retry logic. 276// 277// 278// // Example sending a request using the InputService2TestCaseOperation1Request method. 279// req, resp := client.InputService2TestCaseOperation1Request(params) 280// 281// err := req.Send() 282// if err == nil { // resp is now filled 283// fmt.Println(resp) 284// } 285func (c *InputService2ProtocolTest) InputService2TestCaseOperation1Request(input *InputService2TestShapeInputService2TestCaseOperation1Input) (req *request.Request, output *InputService2TestShapeInputService2TestCaseOperation1Output) { 286 op := &request.Operation{ 287 Name: opInputService2TestCaseOperation1, 288 HTTPPath: "/", 289 } 290 291 if input == nil { 292 input = &InputService2TestShapeInputService2TestCaseOperation1Input{} 293 } 294 295 output = &InputService2TestShapeInputService2TestCaseOperation1Output{} 296 req = c.newRequest(op, input, output) 297 req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler) 298 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 299 return 300} 301 302// InputService2TestCaseOperation1 API operation for . 303// 304// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 305// with awserr.Error's Code and Message methods to get detailed information about 306// the error. 307// 308// See the AWS API reference guide for 's 309// API operation InputService2TestCaseOperation1 for usage and error information. 310func (c *InputService2ProtocolTest) InputService2TestCaseOperation1(input *InputService2TestShapeInputService2TestCaseOperation1Input) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) { 311 req, out := c.InputService2TestCaseOperation1Request(input) 312 return out, req.Send() 313} 314 315// InputService2TestCaseOperation1WithContext is the same as InputService2TestCaseOperation1 with the addition of 316// the ability to pass a context and additional request options. 317// 318// See InputService2TestCaseOperation1 for details on how to use this API operation. 319// 320// The context must be non-nil and will be used for request cancellation. If 321// the context is nil a panic will occur. In the future the SDK may create 322// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 323// for more information on using Contexts. 324func (c *InputService2ProtocolTest) InputService2TestCaseOperation1WithContext(ctx aws.Context, input *InputService2TestShapeInputService2TestCaseOperation1Input, opts ...request.Option) (*InputService2TestShapeInputService2TestCaseOperation1Output, error) { 325 req, out := c.InputService2TestCaseOperation1Request(input) 326 req.SetContext(ctx) 327 req.ApplyOptions(opts...) 328 return out, req.Send() 329} 330 331type InputService2TestShapeInputService2TestCaseOperation1Input struct { 332 _ struct{} `type:"structure"` 333 334 Bar *string `locationName:"barLocationName" type:"string"` 335 336 Foo *string `type:"string"` 337 338 Yuck *string `locationName:"yuckLocationName" queryName:"yuckQueryName" type:"string"` 339} 340 341// SetBar sets the Bar field's value. 342func (s *InputService2TestShapeInputService2TestCaseOperation1Input) SetBar(v string) *InputService2TestShapeInputService2TestCaseOperation1Input { 343 s.Bar = &v 344 return s 345} 346 347// SetFoo sets the Foo field's value. 348func (s *InputService2TestShapeInputService2TestCaseOperation1Input) SetFoo(v string) *InputService2TestShapeInputService2TestCaseOperation1Input { 349 s.Foo = &v 350 return s 351} 352 353// SetYuck sets the Yuck field's value. 354func (s *InputService2TestShapeInputService2TestCaseOperation1Input) SetYuck(v string) *InputService2TestShapeInputService2TestCaseOperation1Input { 355 s.Yuck = &v 356 return s 357} 358 359type InputService2TestShapeInputService2TestCaseOperation1Output struct { 360 _ struct{} `type:"structure"` 361} 362 363// InputService3ProtocolTest provides the API operation methods for making requests to 364// . See this package's package overview docs 365// for details on the service. 366// 367// InputService3ProtocolTest methods are safe to use concurrently. It is not safe to 368// modify mutate any of the struct's properties though. 369type InputService3ProtocolTest struct { 370 *client.Client 371} 372 373// New creates a new instance of the InputService3ProtocolTest client with a session. 374// If additional configuration is needed for the client instance use the optional 375// aws.Config parameter to add your extra config. 376// 377// Example: 378// // Create a InputService3ProtocolTest client from just a session. 379// svc := inputservice3protocoltest.New(mySession) 380// 381// // Create a InputService3ProtocolTest client with additional configuration 382// svc := inputservice3protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 383func NewInputService3ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService3ProtocolTest { 384 c := p.ClientConfig("inputservice3protocoltest", cfgs...) 385 return newInputService3ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 386} 387 388// newClient creates, initializes and returns a new service client instance. 389func newInputService3ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService3ProtocolTest { 390 svc := &InputService3ProtocolTest{ 391 Client: client.New( 392 cfg, 393 metadata.ClientInfo{ 394 ServiceName: "InputService3ProtocolTest", 395 ServiceID: "InputService3ProtocolTest", 396 SigningName: signingName, 397 SigningRegion: signingRegion, 398 Endpoint: endpoint, 399 APIVersion: "2014-01-01", 400 }, 401 handlers, 402 ), 403 } 404 405 // Handlers 406 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 407 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 408 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 409 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 410 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 411 412 return svc 413} 414 415// newRequest creates a new request for a InputService3ProtocolTest operation and runs any 416// custom request initialization. 417func (c *InputService3ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 418 req := c.NewRequest(op, params, data) 419 420 return req 421} 422 423const opInputService3TestCaseOperation1 = "OperationName" 424 425// InputService3TestCaseOperation1Request generates a "aws/request.Request" representing the 426// client's request for the InputService3TestCaseOperation1 operation. The "output" return 427// value will be populated with the request's response once the request completes 428// successfuly. 429// 430// Use "Send" method on the returned Request to send the API call to the service. 431// the "output" return value is not valid until after Send returns without error. 432// 433// See InputService3TestCaseOperation1 for more information on using the InputService3TestCaseOperation1 434// API call, and error handling. 435// 436// This method is useful when you want to inject custom logic or configuration 437// into the SDK's request lifecycle. Such as custom headers, or retry logic. 438// 439// 440// // Example sending a request using the InputService3TestCaseOperation1Request method. 441// req, resp := client.InputService3TestCaseOperation1Request(params) 442// 443// err := req.Send() 444// if err == nil { // resp is now filled 445// fmt.Println(resp) 446// } 447func (c *InputService3ProtocolTest) InputService3TestCaseOperation1Request(input *InputService3TestShapeInputService3TestCaseOperation1Input) (req *request.Request, output *InputService3TestShapeInputService3TestCaseOperation1Output) { 448 op := &request.Operation{ 449 Name: opInputService3TestCaseOperation1, 450 HTTPPath: "/", 451 } 452 453 if input == nil { 454 input = &InputService3TestShapeInputService3TestCaseOperation1Input{} 455 } 456 457 output = &InputService3TestShapeInputService3TestCaseOperation1Output{} 458 req = c.newRequest(op, input, output) 459 req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler) 460 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 461 return 462} 463 464// InputService3TestCaseOperation1 API operation for . 465// 466// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 467// with awserr.Error's Code and Message methods to get detailed information about 468// the error. 469// 470// See the AWS API reference guide for 's 471// API operation InputService3TestCaseOperation1 for usage and error information. 472func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputService3TestCaseOperation1Input) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) { 473 req, out := c.InputService3TestCaseOperation1Request(input) 474 return out, req.Send() 475} 476 477// InputService3TestCaseOperation1WithContext is the same as InputService3TestCaseOperation1 with the addition of 478// the ability to pass a context and additional request options. 479// 480// See InputService3TestCaseOperation1 for details on how to use this API operation. 481// 482// The context must be non-nil and will be used for request cancellation. If 483// the context is nil a panic will occur. In the future the SDK may create 484// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 485// for more information on using Contexts. 486func (c *InputService3ProtocolTest) InputService3TestCaseOperation1WithContext(ctx aws.Context, input *InputService3TestShapeInputService3TestCaseOperation1Input, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) { 487 req, out := c.InputService3TestCaseOperation1Request(input) 488 req.SetContext(ctx) 489 req.ApplyOptions(opts...) 490 return out, req.Send() 491} 492 493type InputService3TestShapeInputService3TestCaseOperation1Input struct { 494 _ struct{} `type:"structure"` 495 496 StructArg *InputService3TestShapeStructType `locationName:"Struct" type:"structure"` 497} 498 499// SetStructArg sets the StructArg field's value. 500func (s *InputService3TestShapeInputService3TestCaseOperation1Input) SetStructArg(v *InputService3TestShapeStructType) *InputService3TestShapeInputService3TestCaseOperation1Input { 501 s.StructArg = v 502 return s 503} 504 505type InputService3TestShapeInputService3TestCaseOperation1Output struct { 506 _ struct{} `type:"structure"` 507} 508 509type InputService3TestShapeStructType struct { 510 _ struct{} `type:"structure"` 511 512 ScalarArg *string `locationName:"Scalar" type:"string"` 513} 514 515// SetScalarArg sets the ScalarArg field's value. 516func (s *InputService3TestShapeStructType) SetScalarArg(v string) *InputService3TestShapeStructType { 517 s.ScalarArg = &v 518 return s 519} 520 521// InputService4ProtocolTest provides the API operation methods for making requests to 522// . See this package's package overview docs 523// for details on the service. 524// 525// InputService4ProtocolTest methods are safe to use concurrently. It is not safe to 526// modify mutate any of the struct's properties though. 527type InputService4ProtocolTest struct { 528 *client.Client 529} 530 531// New creates a new instance of the InputService4ProtocolTest client with a session. 532// If additional configuration is needed for the client instance use the optional 533// aws.Config parameter to add your extra config. 534// 535// Example: 536// // Create a InputService4ProtocolTest client from just a session. 537// svc := inputservice4protocoltest.New(mySession) 538// 539// // Create a InputService4ProtocolTest client with additional configuration 540// svc := inputservice4protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 541func NewInputService4ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService4ProtocolTest { 542 c := p.ClientConfig("inputservice4protocoltest", cfgs...) 543 return newInputService4ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 544} 545 546// newClient creates, initializes and returns a new service client instance. 547func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService4ProtocolTest { 548 svc := &InputService4ProtocolTest{ 549 Client: client.New( 550 cfg, 551 metadata.ClientInfo{ 552 ServiceName: "InputService4ProtocolTest", 553 ServiceID: "InputService4ProtocolTest", 554 SigningName: signingName, 555 SigningRegion: signingRegion, 556 Endpoint: endpoint, 557 APIVersion: "2014-01-01", 558 }, 559 handlers, 560 ), 561 } 562 563 // Handlers 564 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 565 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 566 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 567 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 568 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 569 570 return svc 571} 572 573// newRequest creates a new request for a InputService4ProtocolTest operation and runs any 574// custom request initialization. 575func (c *InputService4ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 576 req := c.NewRequest(op, params, data) 577 578 return req 579} 580 581const opInputService4TestCaseOperation1 = "OperationName" 582 583// InputService4TestCaseOperation1Request generates a "aws/request.Request" representing the 584// client's request for the InputService4TestCaseOperation1 operation. The "output" return 585// value will be populated with the request's response once the request completes 586// successfuly. 587// 588// Use "Send" method on the returned Request to send the API call to the service. 589// the "output" return value is not valid until after Send returns without error. 590// 591// See InputService4TestCaseOperation1 for more information on using the InputService4TestCaseOperation1 592// API call, and error handling. 593// 594// This method is useful when you want to inject custom logic or configuration 595// into the SDK's request lifecycle. Such as custom headers, or retry logic. 596// 597// 598// // Example sending a request using the InputService4TestCaseOperation1Request method. 599// req, resp := client.InputService4TestCaseOperation1Request(params) 600// 601// err := req.Send() 602// if err == nil { // resp is now filled 603// fmt.Println(resp) 604// } 605func (c *InputService4ProtocolTest) InputService4TestCaseOperation1Request(input *InputService4TestShapeInputService4TestCaseOperation1Input) (req *request.Request, output *InputService4TestShapeInputService4TestCaseOperation1Output) { 606 op := &request.Operation{ 607 Name: opInputService4TestCaseOperation1, 608 HTTPPath: "/", 609 } 610 611 if input == nil { 612 input = &InputService4TestShapeInputService4TestCaseOperation1Input{} 613 } 614 615 output = &InputService4TestShapeInputService4TestCaseOperation1Output{} 616 req = c.newRequest(op, input, output) 617 req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler) 618 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 619 return 620} 621 622// InputService4TestCaseOperation1 API operation for . 623// 624// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 625// with awserr.Error's Code and Message methods to get detailed information about 626// the error. 627// 628// See the AWS API reference guide for 's 629// API operation InputService4TestCaseOperation1 for usage and error information. 630func (c *InputService4ProtocolTest) InputService4TestCaseOperation1(input *InputService4TestShapeInputService4TestCaseOperation1Input) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) { 631 req, out := c.InputService4TestCaseOperation1Request(input) 632 return out, req.Send() 633} 634 635// InputService4TestCaseOperation1WithContext is the same as InputService4TestCaseOperation1 with the addition of 636// the ability to pass a context and additional request options. 637// 638// See InputService4TestCaseOperation1 for details on how to use this API operation. 639// 640// The context must be non-nil and will be used for request cancellation. If 641// the context is nil a panic will occur. In the future the SDK may create 642// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 643// for more information on using Contexts. 644func (c *InputService4ProtocolTest) InputService4TestCaseOperation1WithContext(ctx aws.Context, input *InputService4TestShapeInputService4TestCaseOperation1Input, opts ...request.Option) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) { 645 req, out := c.InputService4TestCaseOperation1Request(input) 646 req.SetContext(ctx) 647 req.ApplyOptions(opts...) 648 return out, req.Send() 649} 650 651type InputService4TestShapeInputService4TestCaseOperation1Input struct { 652 _ struct{} `type:"structure"` 653 654 ListBools []*bool `type:"list"` 655 656 ListFloats []*float64 `type:"list"` 657 658 ListIntegers []*int64 `type:"list"` 659 660 ListStrings []*string `type:"list"` 661} 662 663// SetListBools sets the ListBools field's value. 664func (s *InputService4TestShapeInputService4TestCaseOperation1Input) SetListBools(v []*bool) *InputService4TestShapeInputService4TestCaseOperation1Input { 665 s.ListBools = v 666 return s 667} 668 669// SetListFloats sets the ListFloats field's value. 670func (s *InputService4TestShapeInputService4TestCaseOperation1Input) SetListFloats(v []*float64) *InputService4TestShapeInputService4TestCaseOperation1Input { 671 s.ListFloats = v 672 return s 673} 674 675// SetListIntegers sets the ListIntegers field's value. 676func (s *InputService4TestShapeInputService4TestCaseOperation1Input) SetListIntegers(v []*int64) *InputService4TestShapeInputService4TestCaseOperation1Input { 677 s.ListIntegers = v 678 return s 679} 680 681// SetListStrings sets the ListStrings field's value. 682func (s *InputService4TestShapeInputService4TestCaseOperation1Input) SetListStrings(v []*string) *InputService4TestShapeInputService4TestCaseOperation1Input { 683 s.ListStrings = v 684 return s 685} 686 687type InputService4TestShapeInputService4TestCaseOperation1Output struct { 688 _ struct{} `type:"structure"` 689} 690 691// InputService5ProtocolTest provides the API operation methods for making requests to 692// . See this package's package overview docs 693// for details on the service. 694// 695// InputService5ProtocolTest methods are safe to use concurrently. It is not safe to 696// modify mutate any of the struct's properties though. 697type InputService5ProtocolTest struct { 698 *client.Client 699} 700 701// New creates a new instance of the InputService5ProtocolTest client with a session. 702// If additional configuration is needed for the client instance use the optional 703// aws.Config parameter to add your extra config. 704// 705// Example: 706// // Create a InputService5ProtocolTest client from just a session. 707// svc := inputservice5protocoltest.New(mySession) 708// 709// // Create a InputService5ProtocolTest client with additional configuration 710// svc := inputservice5protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 711func NewInputService5ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService5ProtocolTest { 712 c := p.ClientConfig("inputservice5protocoltest", cfgs...) 713 return newInputService5ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 714} 715 716// newClient creates, initializes and returns a new service client instance. 717func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService5ProtocolTest { 718 svc := &InputService5ProtocolTest{ 719 Client: client.New( 720 cfg, 721 metadata.ClientInfo{ 722 ServiceName: "InputService5ProtocolTest", 723 ServiceID: "InputService5ProtocolTest", 724 SigningName: signingName, 725 SigningRegion: signingRegion, 726 Endpoint: endpoint, 727 APIVersion: "2014-01-01", 728 }, 729 handlers, 730 ), 731 } 732 733 // Handlers 734 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 735 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 736 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 737 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 738 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 739 740 return svc 741} 742 743// newRequest creates a new request for a InputService5ProtocolTest operation and runs any 744// custom request initialization. 745func (c *InputService5ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 746 req := c.NewRequest(op, params, data) 747 748 return req 749} 750 751const opInputService5TestCaseOperation1 = "OperationName" 752 753// InputService5TestCaseOperation1Request generates a "aws/request.Request" representing the 754// client's request for the InputService5TestCaseOperation1 operation. The "output" return 755// value will be populated with the request's response once the request completes 756// successfuly. 757// 758// Use "Send" method on the returned Request to send the API call to the service. 759// the "output" return value is not valid until after Send returns without error. 760// 761// See InputService5TestCaseOperation1 for more information on using the InputService5TestCaseOperation1 762// API call, and error handling. 763// 764// This method is useful when you want to inject custom logic or configuration 765// into the SDK's request lifecycle. Such as custom headers, or retry logic. 766// 767// 768// // Example sending a request using the InputService5TestCaseOperation1Request method. 769// req, resp := client.InputService5TestCaseOperation1Request(params) 770// 771// err := req.Send() 772// if err == nil { // resp is now filled 773// fmt.Println(resp) 774// } 775func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputService5TestCaseOperation1Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) { 776 op := &request.Operation{ 777 Name: opInputService5TestCaseOperation1, 778 HTTPPath: "/", 779 } 780 781 if input == nil { 782 input = &InputService5TestShapeInputService5TestCaseOperation1Input{} 783 } 784 785 output = &InputService5TestShapeInputService5TestCaseOperation1Output{} 786 req = c.newRequest(op, input, output) 787 req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler) 788 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 789 return 790} 791 792// InputService5TestCaseOperation1 API operation for . 793// 794// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 795// with awserr.Error's Code and Message methods to get detailed information about 796// the error. 797// 798// See the AWS API reference guide for 's 799// API operation InputService5TestCaseOperation1 for usage and error information. 800func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputService5TestCaseOperation1Input) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) { 801 req, out := c.InputService5TestCaseOperation1Request(input) 802 return out, req.Send() 803} 804 805// InputService5TestCaseOperation1WithContext is the same as InputService5TestCaseOperation1 with the addition of 806// the ability to pass a context and additional request options. 807// 808// See InputService5TestCaseOperation1 for details on how to use this API operation. 809// 810// The context must be non-nil and will be used for request cancellation. If 811// the context is nil a panic will occur. In the future the SDK may create 812// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 813// for more information on using Contexts. 814func (c *InputService5ProtocolTest) InputService5TestCaseOperation1WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation1Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) { 815 req, out := c.InputService5TestCaseOperation1Request(input) 816 req.SetContext(ctx) 817 req.ApplyOptions(opts...) 818 return out, req.Send() 819} 820 821type InputService5TestShapeInputService5TestCaseOperation1Input struct { 822 _ struct{} `type:"structure"` 823 824 ListArg []*string `locationName:"ListMemberName" locationNameList:"item" type:"list"` 825} 826 827// SetListArg sets the ListArg field's value. 828func (s *InputService5TestShapeInputService5TestCaseOperation1Input) SetListArg(v []*string) *InputService5TestShapeInputService5TestCaseOperation1Input { 829 s.ListArg = v 830 return s 831} 832 833type InputService5TestShapeInputService5TestCaseOperation1Output struct { 834 _ struct{} `type:"structure"` 835} 836 837// InputService6ProtocolTest provides the API operation methods for making requests to 838// . See this package's package overview docs 839// for details on the service. 840// 841// InputService6ProtocolTest methods are safe to use concurrently. It is not safe to 842// modify mutate any of the struct's properties though. 843type InputService6ProtocolTest struct { 844 *client.Client 845} 846 847// New creates a new instance of the InputService6ProtocolTest client with a session. 848// If additional configuration is needed for the client instance use the optional 849// aws.Config parameter to add your extra config. 850// 851// Example: 852// // Create a InputService6ProtocolTest client from just a session. 853// svc := inputservice6protocoltest.New(mySession) 854// 855// // Create a InputService6ProtocolTest client with additional configuration 856// svc := inputservice6protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 857func NewInputService6ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService6ProtocolTest { 858 c := p.ClientConfig("inputservice6protocoltest", cfgs...) 859 return newInputService6ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 860} 861 862// newClient creates, initializes and returns a new service client instance. 863func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService6ProtocolTest { 864 svc := &InputService6ProtocolTest{ 865 Client: client.New( 866 cfg, 867 metadata.ClientInfo{ 868 ServiceName: "InputService6ProtocolTest", 869 ServiceID: "InputService6ProtocolTest", 870 SigningName: signingName, 871 SigningRegion: signingRegion, 872 Endpoint: endpoint, 873 APIVersion: "2014-01-01", 874 }, 875 handlers, 876 ), 877 } 878 879 // Handlers 880 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 881 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 882 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 883 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 884 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 885 886 return svc 887} 888 889// newRequest creates a new request for a InputService6ProtocolTest operation and runs any 890// custom request initialization. 891func (c *InputService6ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 892 req := c.NewRequest(op, params, data) 893 894 return req 895} 896 897const opInputService6TestCaseOperation1 = "OperationName" 898 899// InputService6TestCaseOperation1Request generates a "aws/request.Request" representing the 900// client's request for the InputService6TestCaseOperation1 operation. The "output" return 901// value will be populated with the request's response once the request completes 902// successfuly. 903// 904// Use "Send" method on the returned Request to send the API call to the service. 905// the "output" return value is not valid until after Send returns without error. 906// 907// See InputService6TestCaseOperation1 for more information on using the InputService6TestCaseOperation1 908// API call, and error handling. 909// 910// This method is useful when you want to inject custom logic or configuration 911// into the SDK's request lifecycle. Such as custom headers, or retry logic. 912// 913// 914// // Example sending a request using the InputService6TestCaseOperation1Request method. 915// req, resp := client.InputService6TestCaseOperation1Request(params) 916// 917// err := req.Send() 918// if err == nil { // resp is now filled 919// fmt.Println(resp) 920// } 921func (c *InputService6ProtocolTest) InputService6TestCaseOperation1Request(input *InputService6TestShapeInputService6TestCaseOperation1Input) (req *request.Request, output *InputService6TestShapeInputService6TestCaseOperation1Output) { 922 op := &request.Operation{ 923 Name: opInputService6TestCaseOperation1, 924 HTTPPath: "/", 925 } 926 927 if input == nil { 928 input = &InputService6TestShapeInputService6TestCaseOperation1Input{} 929 } 930 931 output = &InputService6TestShapeInputService6TestCaseOperation1Output{} 932 req = c.newRequest(op, input, output) 933 req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler) 934 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 935 return 936} 937 938// InputService6TestCaseOperation1 API operation for . 939// 940// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 941// with awserr.Error's Code and Message methods to get detailed information about 942// the error. 943// 944// See the AWS API reference guide for 's 945// API operation InputService6TestCaseOperation1 for usage and error information. 946func (c *InputService6ProtocolTest) InputService6TestCaseOperation1(input *InputService6TestShapeInputService6TestCaseOperation1Input) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) { 947 req, out := c.InputService6TestCaseOperation1Request(input) 948 return out, req.Send() 949} 950 951// InputService6TestCaseOperation1WithContext is the same as InputService6TestCaseOperation1 with the addition of 952// the ability to pass a context and additional request options. 953// 954// See InputService6TestCaseOperation1 for details on how to use this API operation. 955// 956// The context must be non-nil and will be used for request cancellation. If 957// the context is nil a panic will occur. In the future the SDK may create 958// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 959// for more information on using Contexts. 960func (c *InputService6ProtocolTest) InputService6TestCaseOperation1WithContext(ctx aws.Context, input *InputService6TestShapeInputService6TestCaseOperation1Input, opts ...request.Option) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) { 961 req, out := c.InputService6TestCaseOperation1Request(input) 962 req.SetContext(ctx) 963 req.ApplyOptions(opts...) 964 return out, req.Send() 965} 966 967type InputService6TestShapeInputService6TestCaseOperation1Input struct { 968 _ struct{} `type:"structure"` 969 970 ListArg []*string `locationName:"ListMemberName" queryName:"ListQueryName" locationNameList:"item" type:"list"` 971} 972 973// SetListArg sets the ListArg field's value. 974func (s *InputService6TestShapeInputService6TestCaseOperation1Input) SetListArg(v []*string) *InputService6TestShapeInputService6TestCaseOperation1Input { 975 s.ListArg = v 976 return s 977} 978 979type InputService6TestShapeInputService6TestCaseOperation1Output struct { 980 _ struct{} `type:"structure"` 981} 982 983// InputService7ProtocolTest provides the API operation methods for making requests to 984// . See this package's package overview docs 985// for details on the service. 986// 987// InputService7ProtocolTest methods are safe to use concurrently. It is not safe to 988// modify mutate any of the struct's properties though. 989type InputService7ProtocolTest struct { 990 *client.Client 991} 992 993// New creates a new instance of the InputService7ProtocolTest client with a session. 994// If additional configuration is needed for the client instance use the optional 995// aws.Config parameter to add your extra config. 996// 997// Example: 998// // Create a InputService7ProtocolTest client from just a session. 999// svc := inputservice7protocoltest.New(mySession) 1000// 1001// // Create a InputService7ProtocolTest client with additional configuration 1002// svc := inputservice7protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1003func NewInputService7ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService7ProtocolTest { 1004 c := p.ClientConfig("inputservice7protocoltest", cfgs...) 1005 return newInputService7ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1006} 1007 1008// newClient creates, initializes and returns a new service client instance. 1009func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService7ProtocolTest { 1010 svc := &InputService7ProtocolTest{ 1011 Client: client.New( 1012 cfg, 1013 metadata.ClientInfo{ 1014 ServiceName: "InputService7ProtocolTest", 1015 ServiceID: "InputService7ProtocolTest", 1016 SigningName: signingName, 1017 SigningRegion: signingRegion, 1018 Endpoint: endpoint, 1019 APIVersion: "2014-01-01", 1020 }, 1021 handlers, 1022 ), 1023 } 1024 1025 // Handlers 1026 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1027 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 1028 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 1029 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 1030 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 1031 1032 return svc 1033} 1034 1035// newRequest creates a new request for a InputService7ProtocolTest operation and runs any 1036// custom request initialization. 1037func (c *InputService7ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1038 req := c.NewRequest(op, params, data) 1039 1040 return req 1041} 1042 1043const opInputService7TestCaseOperation1 = "OperationName" 1044 1045// InputService7TestCaseOperation1Request generates a "aws/request.Request" representing the 1046// client's request for the InputService7TestCaseOperation1 operation. The "output" return 1047// value will be populated with the request's response once the request completes 1048// successfuly. 1049// 1050// Use "Send" method on the returned Request to send the API call to the service. 1051// the "output" return value is not valid until after Send returns without error. 1052// 1053// See InputService7TestCaseOperation1 for more information on using the InputService7TestCaseOperation1 1054// API call, and error handling. 1055// 1056// This method is useful when you want to inject custom logic or configuration 1057// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1058// 1059// 1060// // Example sending a request using the InputService7TestCaseOperation1Request method. 1061// req, resp := client.InputService7TestCaseOperation1Request(params) 1062// 1063// err := req.Send() 1064// if err == nil { // resp is now filled 1065// fmt.Println(resp) 1066// } 1067func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputService7TestCaseOperation1Input) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) { 1068 op := &request.Operation{ 1069 Name: opInputService7TestCaseOperation1, 1070 HTTPPath: "/", 1071 } 1072 1073 if input == nil { 1074 input = &InputService7TestShapeInputService7TestCaseOperation1Input{} 1075 } 1076 1077 output = &InputService7TestShapeInputService7TestCaseOperation1Output{} 1078 req = c.newRequest(op, input, output) 1079 req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler) 1080 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1081 return 1082} 1083 1084// InputService7TestCaseOperation1 API operation for . 1085// 1086// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1087// with awserr.Error's Code and Message methods to get detailed information about 1088// the error. 1089// 1090// See the AWS API reference guide for 's 1091// API operation InputService7TestCaseOperation1 for usage and error information. 1092func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputService7TestCaseOperation1Input) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) { 1093 req, out := c.InputService7TestCaseOperation1Request(input) 1094 return out, req.Send() 1095} 1096 1097// InputService7TestCaseOperation1WithContext is the same as InputService7TestCaseOperation1 with the addition of 1098// the ability to pass a context and additional request options. 1099// 1100// See InputService7TestCaseOperation1 for details on how to use this API operation. 1101// 1102// The context must be non-nil and will be used for request cancellation. If 1103// the context is nil a panic will occur. In the future the SDK may create 1104// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1105// for more information on using Contexts. 1106func (c *InputService7ProtocolTest) InputService7TestCaseOperation1WithContext(ctx aws.Context, input *InputService7TestShapeInputService7TestCaseOperation1Input, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) { 1107 req, out := c.InputService7TestCaseOperation1Request(input) 1108 req.SetContext(ctx) 1109 req.ApplyOptions(opts...) 1110 return out, req.Send() 1111} 1112 1113type InputService7TestShapeInputService7TestCaseOperation1Input struct { 1114 _ struct{} `type:"structure"` 1115 1116 // BlobArg is automatically base64 encoded/decoded by the SDK. 1117 BlobArg []byte `type:"blob"` 1118} 1119 1120// SetBlobArg sets the BlobArg field's value. 1121func (s *InputService7TestShapeInputService7TestCaseOperation1Input) SetBlobArg(v []byte) *InputService7TestShapeInputService7TestCaseOperation1Input { 1122 s.BlobArg = v 1123 return s 1124} 1125 1126type InputService7TestShapeInputService7TestCaseOperation1Output struct { 1127 _ struct{} `type:"structure"` 1128} 1129 1130// InputService8ProtocolTest provides the API operation methods for making requests to 1131// . See this package's package overview docs 1132// for details on the service. 1133// 1134// InputService8ProtocolTest methods are safe to use concurrently. It is not safe to 1135// modify mutate any of the struct's properties though. 1136type InputService8ProtocolTest struct { 1137 *client.Client 1138} 1139 1140// New creates a new instance of the InputService8ProtocolTest client with a session. 1141// If additional configuration is needed for the client instance use the optional 1142// aws.Config parameter to add your extra config. 1143// 1144// Example: 1145// // Create a InputService8ProtocolTest client from just a session. 1146// svc := inputservice8protocoltest.New(mySession) 1147// 1148// // Create a InputService8ProtocolTest client with additional configuration 1149// svc := inputservice8protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1150func NewInputService8ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService8ProtocolTest { 1151 c := p.ClientConfig("inputservice8protocoltest", cfgs...) 1152 return newInputService8ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1153} 1154 1155// newClient creates, initializes and returns a new service client instance. 1156func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService8ProtocolTest { 1157 svc := &InputService8ProtocolTest{ 1158 Client: client.New( 1159 cfg, 1160 metadata.ClientInfo{ 1161 ServiceName: "InputService8ProtocolTest", 1162 ServiceID: "InputService8ProtocolTest", 1163 SigningName: signingName, 1164 SigningRegion: signingRegion, 1165 Endpoint: endpoint, 1166 APIVersion: "2014-01-01", 1167 }, 1168 handlers, 1169 ), 1170 } 1171 1172 // Handlers 1173 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1174 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 1175 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 1176 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 1177 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 1178 1179 return svc 1180} 1181 1182// newRequest creates a new request for a InputService8ProtocolTest operation and runs any 1183// custom request initialization. 1184func (c *InputService8ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1185 req := c.NewRequest(op, params, data) 1186 1187 return req 1188} 1189 1190const opInputService8TestCaseOperation1 = "OperationName" 1191 1192// InputService8TestCaseOperation1Request generates a "aws/request.Request" representing the 1193// client's request for the InputService8TestCaseOperation1 operation. The "output" return 1194// value will be populated with the request's response once the request completes 1195// successfuly. 1196// 1197// Use "Send" method on the returned Request to send the API call to the service. 1198// the "output" return value is not valid until after Send returns without error. 1199// 1200// See InputService8TestCaseOperation1 for more information on using the InputService8TestCaseOperation1 1201// API call, and error handling. 1202// 1203// This method is useful when you want to inject custom logic or configuration 1204// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1205// 1206// 1207// // Example sending a request using the InputService8TestCaseOperation1Request method. 1208// req, resp := client.InputService8TestCaseOperation1Request(params) 1209// 1210// err := req.Send() 1211// if err == nil { // resp is now filled 1212// fmt.Println(resp) 1213// } 1214func (c *InputService8ProtocolTest) InputService8TestCaseOperation1Request(input *InputService8TestShapeInputService8TestCaseOperation1Input) (req *request.Request, output *InputService8TestShapeInputService8TestCaseOperation1Output) { 1215 op := &request.Operation{ 1216 Name: opInputService8TestCaseOperation1, 1217 HTTPPath: "/", 1218 } 1219 1220 if input == nil { 1221 input = &InputService8TestShapeInputService8TestCaseOperation1Input{} 1222 } 1223 1224 output = &InputService8TestShapeInputService8TestCaseOperation1Output{} 1225 req = c.newRequest(op, input, output) 1226 req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler) 1227 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1228 return 1229} 1230 1231// InputService8TestCaseOperation1 API operation for . 1232// 1233// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1234// with awserr.Error's Code and Message methods to get detailed information about 1235// the error. 1236// 1237// See the AWS API reference guide for 's 1238// API operation InputService8TestCaseOperation1 for usage and error information. 1239func (c *InputService8ProtocolTest) InputService8TestCaseOperation1(input *InputService8TestShapeInputService8TestCaseOperation1Input) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) { 1240 req, out := c.InputService8TestCaseOperation1Request(input) 1241 return out, req.Send() 1242} 1243 1244// InputService8TestCaseOperation1WithContext is the same as InputService8TestCaseOperation1 with the addition of 1245// the ability to pass a context and additional request options. 1246// 1247// See InputService8TestCaseOperation1 for details on how to use this API operation. 1248// 1249// The context must be non-nil and will be used for request cancellation. If 1250// the context is nil a panic will occur. In the future the SDK may create 1251// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1252// for more information on using Contexts. 1253func (c *InputService8ProtocolTest) InputService8TestCaseOperation1WithContext(ctx aws.Context, input *InputService8TestShapeInputService8TestCaseOperation1Input, opts ...request.Option) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) { 1254 req, out := c.InputService8TestCaseOperation1Request(input) 1255 req.SetContext(ctx) 1256 req.ApplyOptions(opts...) 1257 return out, req.Send() 1258} 1259 1260type InputService8TestShapeInputService8TestCaseOperation1Input struct { 1261 _ struct{} `type:"structure"` 1262 1263 TimeArg *time.Time `type:"timestamp" timestampFormat:"iso8601"` 1264} 1265 1266// SetTimeArg sets the TimeArg field's value. 1267func (s *InputService8TestShapeInputService8TestCaseOperation1Input) SetTimeArg(v time.Time) *InputService8TestShapeInputService8TestCaseOperation1Input { 1268 s.TimeArg = &v 1269 return s 1270} 1271 1272type InputService8TestShapeInputService8TestCaseOperation1Output struct { 1273 _ struct{} `type:"structure"` 1274} 1275 1276// InputService9ProtocolTest provides the API operation methods for making requests to 1277// . See this package's package overview docs 1278// for details on the service. 1279// 1280// InputService9ProtocolTest methods are safe to use concurrently. It is not safe to 1281// modify mutate any of the struct's properties though. 1282type InputService9ProtocolTest struct { 1283 *client.Client 1284} 1285 1286// New creates a new instance of the InputService9ProtocolTest client with a session. 1287// If additional configuration is needed for the client instance use the optional 1288// aws.Config parameter to add your extra config. 1289// 1290// Example: 1291// // Create a InputService9ProtocolTest client from just a session. 1292// svc := inputservice9protocoltest.New(mySession) 1293// 1294// // Create a InputService9ProtocolTest client with additional configuration 1295// svc := inputservice9protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1296func NewInputService9ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService9ProtocolTest { 1297 c := p.ClientConfig("inputservice9protocoltest", cfgs...) 1298 return newInputService9ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1299} 1300 1301// newClient creates, initializes and returns a new service client instance. 1302func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService9ProtocolTest { 1303 svc := &InputService9ProtocolTest{ 1304 Client: client.New( 1305 cfg, 1306 metadata.ClientInfo{ 1307 ServiceName: "InputService9ProtocolTest", 1308 ServiceID: "InputService9ProtocolTest", 1309 SigningName: signingName, 1310 SigningRegion: signingRegion, 1311 Endpoint: endpoint, 1312 APIVersion: "2014-01-01", 1313 }, 1314 handlers, 1315 ), 1316 } 1317 1318 // Handlers 1319 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1320 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 1321 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 1322 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 1323 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 1324 1325 return svc 1326} 1327 1328// newRequest creates a new request for a InputService9ProtocolTest operation and runs any 1329// custom request initialization. 1330func (c *InputService9ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1331 req := c.NewRequest(op, params, data) 1332 1333 return req 1334} 1335 1336const opInputService9TestCaseOperation1 = "OperationName" 1337 1338// InputService9TestCaseOperation1Request generates a "aws/request.Request" representing the 1339// client's request for the InputService9TestCaseOperation1 operation. The "output" return 1340// value will be populated with the request's response once the request completes 1341// successfuly. 1342// 1343// Use "Send" method on the returned Request to send the API call to the service. 1344// the "output" return value is not valid until after Send returns without error. 1345// 1346// See InputService9TestCaseOperation1 for more information on using the InputService9TestCaseOperation1 1347// API call, and error handling. 1348// 1349// This method is useful when you want to inject custom logic or configuration 1350// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1351// 1352// 1353// // Example sending a request using the InputService9TestCaseOperation1Request method. 1354// req, resp := client.InputService9TestCaseOperation1Request(params) 1355// 1356// err := req.Send() 1357// if err == nil { // resp is now filled 1358// fmt.Println(resp) 1359// } 1360func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input *InputService9TestShapeInputService9TestCaseOperation2Input) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation1Output) { 1361 op := &request.Operation{ 1362 Name: opInputService9TestCaseOperation1, 1363 HTTPPath: "/", 1364 } 1365 1366 if input == nil { 1367 input = &InputService9TestShapeInputService9TestCaseOperation2Input{} 1368 } 1369 1370 output = &InputService9TestShapeInputService9TestCaseOperation1Output{} 1371 req = c.newRequest(op, input, output) 1372 req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler) 1373 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1374 return 1375} 1376 1377// InputService9TestCaseOperation1 API operation for . 1378// 1379// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1380// with awserr.Error's Code and Message methods to get detailed information about 1381// the error. 1382// 1383// See the AWS API reference guide for 's 1384// API operation InputService9TestCaseOperation1 for usage and error information. 1385func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *InputService9TestShapeInputService9TestCaseOperation2Input) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) { 1386 req, out := c.InputService9TestCaseOperation1Request(input) 1387 return out, req.Send() 1388} 1389 1390// InputService9TestCaseOperation1WithContext is the same as InputService9TestCaseOperation1 with the addition of 1391// the ability to pass a context and additional request options. 1392// 1393// See InputService9TestCaseOperation1 for details on how to use this API operation. 1394// 1395// The context must be non-nil and will be used for request cancellation. If 1396// the context is nil a panic will occur. In the future the SDK may create 1397// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1398// for more information on using Contexts. 1399func (c *InputService9ProtocolTest) InputService9TestCaseOperation1WithContext(ctx aws.Context, input *InputService9TestShapeInputService9TestCaseOperation2Input, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) { 1400 req, out := c.InputService9TestCaseOperation1Request(input) 1401 req.SetContext(ctx) 1402 req.ApplyOptions(opts...) 1403 return out, req.Send() 1404} 1405 1406const opInputService9TestCaseOperation2 = "OperationName" 1407 1408// InputService9TestCaseOperation2Request generates a "aws/request.Request" representing the 1409// client's request for the InputService9TestCaseOperation2 operation. The "output" return 1410// value will be populated with the request's response once the request completes 1411// successfuly. 1412// 1413// Use "Send" method on the returned Request to send the API call to the service. 1414// the "output" return value is not valid until after Send returns without error. 1415// 1416// See InputService9TestCaseOperation2 for more information on using the InputService9TestCaseOperation2 1417// API call, and error handling. 1418// 1419// This method is useful when you want to inject custom logic or configuration 1420// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1421// 1422// 1423// // Example sending a request using the InputService9TestCaseOperation2Request method. 1424// req, resp := client.InputService9TestCaseOperation2Request(params) 1425// 1426// err := req.Send() 1427// if err == nil { // resp is now filled 1428// fmt.Println(resp) 1429// } 1430func (c *InputService9ProtocolTest) InputService9TestCaseOperation2Request(input *InputService9TestShapeInputService9TestCaseOperation2Input) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation2Output) { 1431 op := &request.Operation{ 1432 Name: opInputService9TestCaseOperation2, 1433 HTTPPath: "/", 1434 } 1435 1436 if input == nil { 1437 input = &InputService9TestShapeInputService9TestCaseOperation2Input{} 1438 } 1439 1440 output = &InputService9TestShapeInputService9TestCaseOperation2Output{} 1441 req = c.newRequest(op, input, output) 1442 req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler) 1443 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1444 return 1445} 1446 1447// InputService9TestCaseOperation2 API operation for . 1448// 1449// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1450// with awserr.Error's Code and Message methods to get detailed information about 1451// the error. 1452// 1453// See the AWS API reference guide for 's 1454// API operation InputService9TestCaseOperation2 for usage and error information. 1455func (c *InputService9ProtocolTest) InputService9TestCaseOperation2(input *InputService9TestShapeInputService9TestCaseOperation2Input) (*InputService9TestShapeInputService9TestCaseOperation2Output, error) { 1456 req, out := c.InputService9TestCaseOperation2Request(input) 1457 return out, req.Send() 1458} 1459 1460// InputService9TestCaseOperation2WithContext is the same as InputService9TestCaseOperation2 with the addition of 1461// the ability to pass a context and additional request options. 1462// 1463// See InputService9TestCaseOperation2 for details on how to use this API operation. 1464// 1465// The context must be non-nil and will be used for request cancellation. If 1466// the context is nil a panic will occur. In the future the SDK may create 1467// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1468// for more information on using Contexts. 1469func (c *InputService9ProtocolTest) InputService9TestCaseOperation2WithContext(ctx aws.Context, input *InputService9TestShapeInputService9TestCaseOperation2Input, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation2Output, error) { 1470 req, out := c.InputService9TestCaseOperation2Request(input) 1471 req.SetContext(ctx) 1472 req.ApplyOptions(opts...) 1473 return out, req.Send() 1474} 1475 1476type InputService9TestShapeInputService9TestCaseOperation1Output struct { 1477 _ struct{} `type:"structure"` 1478} 1479 1480type InputService9TestShapeInputService9TestCaseOperation2Input struct { 1481 _ struct{} `type:"structure"` 1482 1483 Token *string `type:"string" idempotencyToken:"true"` 1484} 1485 1486// SetToken sets the Token field's value. 1487func (s *InputService9TestShapeInputService9TestCaseOperation2Input) SetToken(v string) *InputService9TestShapeInputService9TestCaseOperation2Input { 1488 s.Token = &v 1489 return s 1490} 1491 1492type InputService9TestShapeInputService9TestCaseOperation2Output struct { 1493 _ struct{} `type:"structure"` 1494} 1495 1496// InputService10ProtocolTest provides the API operation methods for making requests to 1497// . See this package's package overview docs 1498// for details on the service. 1499// 1500// InputService10ProtocolTest methods are safe to use concurrently. It is not safe to 1501// modify mutate any of the struct's properties though. 1502type InputService10ProtocolTest struct { 1503 *client.Client 1504} 1505 1506// New creates a new instance of the InputService10ProtocolTest client with a session. 1507// If additional configuration is needed for the client instance use the optional 1508// aws.Config parameter to add your extra config. 1509// 1510// Example: 1511// // Create a InputService10ProtocolTest client from just a session. 1512// svc := inputservice10protocoltest.New(mySession) 1513// 1514// // Create a InputService10ProtocolTest client with additional configuration 1515// svc := inputservice10protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1516func NewInputService10ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService10ProtocolTest { 1517 c := p.ClientConfig("inputservice10protocoltest", cfgs...) 1518 return newInputService10ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1519} 1520 1521// newClient creates, initializes and returns a new service client instance. 1522func newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService10ProtocolTest { 1523 svc := &InputService10ProtocolTest{ 1524 Client: client.New( 1525 cfg, 1526 metadata.ClientInfo{ 1527 ServiceName: "InputService10ProtocolTest", 1528 ServiceID: "InputService10ProtocolTest", 1529 SigningName: signingName, 1530 SigningRegion: signingRegion, 1531 Endpoint: endpoint, 1532 APIVersion: "2014-01-01", 1533 }, 1534 handlers, 1535 ), 1536 } 1537 1538 // Handlers 1539 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1540 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 1541 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 1542 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 1543 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 1544 1545 return svc 1546} 1547 1548// newRequest creates a new request for a InputService10ProtocolTest operation and runs any 1549// custom request initialization. 1550func (c *InputService10ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1551 req := c.NewRequest(op, params, data) 1552 1553 return req 1554} 1555 1556const opInputService10TestCaseOperation1 = "OperationName" 1557 1558// InputService10TestCaseOperation1Request generates a "aws/request.Request" representing the 1559// client's request for the InputService10TestCaseOperation1 operation. The "output" return 1560// value will be populated with the request's response once the request completes 1561// successfuly. 1562// 1563// Use "Send" method on the returned Request to send the API call to the service. 1564// the "output" return value is not valid until after Send returns without error. 1565// 1566// See InputService10TestCaseOperation1 for more information on using the InputService10TestCaseOperation1 1567// API call, and error handling. 1568// 1569// This method is useful when you want to inject custom logic or configuration 1570// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1571// 1572// 1573// // Example sending a request using the InputService10TestCaseOperation1Request method. 1574// req, resp := client.InputService10TestCaseOperation1Request(params) 1575// 1576// err := req.Send() 1577// if err == nil { // resp is now filled 1578// fmt.Println(resp) 1579// } 1580func (c *InputService10ProtocolTest) InputService10TestCaseOperation1Request(input *InputService10TestShapeInputService10TestCaseOperation2Input) (req *request.Request, output *InputService10TestShapeInputService10TestCaseOperation1Output) { 1581 op := &request.Operation{ 1582 Name: opInputService10TestCaseOperation1, 1583 HTTPPath: "/", 1584 } 1585 1586 if input == nil { 1587 input = &InputService10TestShapeInputService10TestCaseOperation2Input{} 1588 } 1589 1590 output = &InputService10TestShapeInputService10TestCaseOperation1Output{} 1591 req = c.newRequest(op, input, output) 1592 req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler) 1593 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1594 return 1595} 1596 1597// InputService10TestCaseOperation1 API operation for . 1598// 1599// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1600// with awserr.Error's Code and Message methods to get detailed information about 1601// the error. 1602// 1603// See the AWS API reference guide for 's 1604// API operation InputService10TestCaseOperation1 for usage and error information. 1605func (c *InputService10ProtocolTest) InputService10TestCaseOperation1(input *InputService10TestShapeInputService10TestCaseOperation2Input) (*InputService10TestShapeInputService10TestCaseOperation1Output, error) { 1606 req, out := c.InputService10TestCaseOperation1Request(input) 1607 return out, req.Send() 1608} 1609 1610// InputService10TestCaseOperation1WithContext is the same as InputService10TestCaseOperation1 with the addition of 1611// the ability to pass a context and additional request options. 1612// 1613// See InputService10TestCaseOperation1 for details on how to use this API operation. 1614// 1615// The context must be non-nil and will be used for request cancellation. If 1616// the context is nil a panic will occur. In the future the SDK may create 1617// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1618// for more information on using Contexts. 1619func (c *InputService10ProtocolTest) InputService10TestCaseOperation1WithContext(ctx aws.Context, input *InputService10TestShapeInputService10TestCaseOperation2Input, opts ...request.Option) (*InputService10TestShapeInputService10TestCaseOperation1Output, error) { 1620 req, out := c.InputService10TestCaseOperation1Request(input) 1621 req.SetContext(ctx) 1622 req.ApplyOptions(opts...) 1623 return out, req.Send() 1624} 1625 1626const opInputService10TestCaseOperation2 = "OperationName" 1627 1628// InputService10TestCaseOperation2Request generates a "aws/request.Request" representing the 1629// client's request for the InputService10TestCaseOperation2 operation. The "output" return 1630// value will be populated with the request's response once the request completes 1631// successfuly. 1632// 1633// Use "Send" method on the returned Request to send the API call to the service. 1634// the "output" return value is not valid until after Send returns without error. 1635// 1636// See InputService10TestCaseOperation2 for more information on using the InputService10TestCaseOperation2 1637// API call, and error handling. 1638// 1639// This method is useful when you want to inject custom logic or configuration 1640// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1641// 1642// 1643// // Example sending a request using the InputService10TestCaseOperation2Request method. 1644// req, resp := client.InputService10TestCaseOperation2Request(params) 1645// 1646// err := req.Send() 1647// if err == nil { // resp is now filled 1648// fmt.Println(resp) 1649// } 1650func (c *InputService10ProtocolTest) InputService10TestCaseOperation2Request(input *InputService10TestShapeInputService10TestCaseOperation2Input) (req *request.Request, output *InputService10TestShapeInputService10TestCaseOperation2Output) { 1651 op := &request.Operation{ 1652 Name: opInputService10TestCaseOperation2, 1653 HTTPPath: "/", 1654 } 1655 1656 if input == nil { 1657 input = &InputService10TestShapeInputService10TestCaseOperation2Input{} 1658 } 1659 1660 output = &InputService10TestShapeInputService10TestCaseOperation2Output{} 1661 req = c.newRequest(op, input, output) 1662 req.Handlers.Unmarshal.Remove(ec2query.UnmarshalHandler) 1663 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 1664 return 1665} 1666 1667// InputService10TestCaseOperation2 API operation for . 1668// 1669// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1670// with awserr.Error's Code and Message methods to get detailed information about 1671// the error. 1672// 1673// See the AWS API reference guide for 's 1674// API operation InputService10TestCaseOperation2 for usage and error information. 1675func (c *InputService10ProtocolTest) InputService10TestCaseOperation2(input *InputService10TestShapeInputService10TestCaseOperation2Input) (*InputService10TestShapeInputService10TestCaseOperation2Output, error) { 1676 req, out := c.InputService10TestCaseOperation2Request(input) 1677 return out, req.Send() 1678} 1679 1680// InputService10TestCaseOperation2WithContext is the same as InputService10TestCaseOperation2 with the addition of 1681// the ability to pass a context and additional request options. 1682// 1683// See InputService10TestCaseOperation2 for details on how to use this API operation. 1684// 1685// The context must be non-nil and will be used for request cancellation. If 1686// the context is nil a panic will occur. In the future the SDK may create 1687// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1688// for more information on using Contexts. 1689func (c *InputService10ProtocolTest) InputService10TestCaseOperation2WithContext(ctx aws.Context, input *InputService10TestShapeInputService10TestCaseOperation2Input, opts ...request.Option) (*InputService10TestShapeInputService10TestCaseOperation2Output, error) { 1690 req, out := c.InputService10TestCaseOperation2Request(input) 1691 req.SetContext(ctx) 1692 req.ApplyOptions(opts...) 1693 return out, req.Send() 1694} 1695 1696type InputService10TestShapeInputService10TestCaseOperation1Output struct { 1697 _ struct{} `type:"structure"` 1698} 1699 1700type InputService10TestShapeInputService10TestCaseOperation2Input struct { 1701 _ struct{} `type:"structure"` 1702 1703 FooEnum *string `type:"string" enum:"InputService10TestShapeEnumType"` 1704 1705 ListEnums []*string `type:"list"` 1706} 1707 1708// SetFooEnum sets the FooEnum field's value. 1709func (s *InputService10TestShapeInputService10TestCaseOperation2Input) SetFooEnum(v string) *InputService10TestShapeInputService10TestCaseOperation2Input { 1710 s.FooEnum = &v 1711 return s 1712} 1713 1714// SetListEnums sets the ListEnums field's value. 1715func (s *InputService10TestShapeInputService10TestCaseOperation2Input) SetListEnums(v []*string) *InputService10TestShapeInputService10TestCaseOperation2Input { 1716 s.ListEnums = v 1717 return s 1718} 1719 1720type InputService10TestShapeInputService10TestCaseOperation2Output struct { 1721 _ struct{} `type:"structure"` 1722} 1723 1724const ( 1725 // EnumTypeFoo is a InputService10TestShapeEnumType enum value 1726 EnumTypeFoo = "foo" 1727 1728 // EnumTypeBar is a InputService10TestShapeEnumType enum value 1729 EnumTypeBar = "bar" 1730) 1731 1732// 1733// Tests begin here 1734// 1735 1736func TestInputService1ProtocolTestScalarMembersCase1(t *testing.T) { 1737 svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 1738 input := &InputService1TestShapeInputService1TestCaseOperation1Input{ 1739 Bar: aws.String("val2"), 1740 Foo: aws.String("val1"), 1741 } 1742 req, _ := svc.InputService1TestCaseOperation1Request(input) 1743 r := req.HTTPRequest 1744 1745 // build request 1746 ec2query.Build(req) 1747 if req.Error != nil { 1748 t.Errorf("expect no error, got %v", req.Error) 1749 } 1750 1751 // assert body 1752 if r.Body == nil { 1753 t.Errorf("expect body not to be nil") 1754 } 1755 body, _ := ioutil.ReadAll(r.Body) 1756 awstesting.AssertQuery(t, `Action=OperationName&Bar=val2&Foo=val1&Version=2014-01-01`, util.Trim(string(body))) 1757 1758 // assert URL 1759 awstesting.AssertURL(t, "https://test/", r.URL.String()) 1760 1761 // assert headers 1762 1763} 1764 1765func TestInputService2ProtocolTestStructureWithLocationNameAndQueryNameAppliedToMembersCase1(t *testing.T) { 1766 svc := NewInputService2ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 1767 input := &InputService2TestShapeInputService2TestCaseOperation1Input{ 1768 Bar: aws.String("val2"), 1769 Foo: aws.String("val1"), 1770 Yuck: aws.String("val3"), 1771 } 1772 req, _ := svc.InputService2TestCaseOperation1Request(input) 1773 r := req.HTTPRequest 1774 1775 // build request 1776 ec2query.Build(req) 1777 if req.Error != nil { 1778 t.Errorf("expect no error, got %v", req.Error) 1779 } 1780 1781 // assert body 1782 if r.Body == nil { 1783 t.Errorf("expect body not to be nil") 1784 } 1785 body, _ := ioutil.ReadAll(r.Body) 1786 awstesting.AssertQuery(t, `Action=OperationName&BarLocationName=val2&Foo=val1&Version=2014-01-01&yuckQueryName=val3`, util.Trim(string(body))) 1787 1788 // assert URL 1789 awstesting.AssertURL(t, "https://test/", r.URL.String()) 1790 1791 // assert headers 1792 1793} 1794 1795func TestInputService3ProtocolTestNestedStructureMembersCase1(t *testing.T) { 1796 svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 1797 input := &InputService3TestShapeInputService3TestCaseOperation1Input{ 1798 StructArg: &InputService3TestShapeStructType{ 1799 ScalarArg: aws.String("foo"), 1800 }, 1801 } 1802 req, _ := svc.InputService3TestCaseOperation1Request(input) 1803 r := req.HTTPRequest 1804 1805 // build request 1806 ec2query.Build(req) 1807 if req.Error != nil { 1808 t.Errorf("expect no error, got %v", req.Error) 1809 } 1810 1811 // assert body 1812 if r.Body == nil { 1813 t.Errorf("expect body not to be nil") 1814 } 1815 body, _ := ioutil.ReadAll(r.Body) 1816 awstesting.AssertQuery(t, `Action=OperationName&Struct.Scalar=foo&Version=2014-01-01`, util.Trim(string(body))) 1817 1818 // assert URL 1819 awstesting.AssertURL(t, "https://test/", r.URL.String()) 1820 1821 // assert headers 1822 1823} 1824 1825func TestInputService4ProtocolTestListTypesCase1(t *testing.T) { 1826 svc := NewInputService4ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 1827 input := &InputService4TestShapeInputService4TestCaseOperation1Input{ 1828 ListBools: []*bool{ 1829 aws.Bool(true), 1830 aws.Bool(false), 1831 aws.Bool(false), 1832 }, 1833 ListFloats: []*float64{ 1834 aws.Float64(1.1), 1835 aws.Float64(2.718), 1836 aws.Float64(3.14), 1837 }, 1838 ListIntegers: []*int64{ 1839 aws.Int64(0), 1840 aws.Int64(1), 1841 aws.Int64(2), 1842 }, 1843 ListStrings: []*string{ 1844 aws.String("foo"), 1845 aws.String("bar"), 1846 aws.String("baz"), 1847 }, 1848 } 1849 req, _ := svc.InputService4TestCaseOperation1Request(input) 1850 r := req.HTTPRequest 1851 1852 // build request 1853 ec2query.Build(req) 1854 if req.Error != nil { 1855 t.Errorf("expect no error, got %v", req.Error) 1856 } 1857 1858 // assert body 1859 if r.Body == nil { 1860 t.Errorf("expect body not to be nil") 1861 } 1862 body, _ := ioutil.ReadAll(r.Body) 1863 awstesting.AssertQuery(t, `Action=OperationName&ListBools.1=true&ListBools.2=false&ListBools.3=false&ListFloats.1=1.1&ListFloats.2=2.718&ListFloats.3=3.14&ListIntegers.1=0&ListIntegers.2=1&ListIntegers.3=2&ListStrings.1=foo&ListStrings.2=bar&ListStrings.3=baz&Version=2014-01-01`, util.Trim(string(body))) 1864 1865 // assert URL 1866 awstesting.AssertURL(t, "https://test/", r.URL.String()) 1867 1868 // assert headers 1869 1870} 1871 1872func TestInputService5ProtocolTestListWithLocationNameAppliedToMemberCase1(t *testing.T) { 1873 svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 1874 input := &InputService5TestShapeInputService5TestCaseOperation1Input{ 1875 ListArg: []*string{ 1876 aws.String("a"), 1877 aws.String("b"), 1878 aws.String("c"), 1879 }, 1880 } 1881 req, _ := svc.InputService5TestCaseOperation1Request(input) 1882 r := req.HTTPRequest 1883 1884 // build request 1885 ec2query.Build(req) 1886 if req.Error != nil { 1887 t.Errorf("expect no error, got %v", req.Error) 1888 } 1889 1890 // assert body 1891 if r.Body == nil { 1892 t.Errorf("expect body not to be nil") 1893 } 1894 body, _ := ioutil.ReadAll(r.Body) 1895 awstesting.AssertQuery(t, `Action=OperationName&ListMemberName.1=a&ListMemberName.2=b&ListMemberName.3=c&Version=2014-01-01`, util.Trim(string(body))) 1896 1897 // assert URL 1898 awstesting.AssertURL(t, "https://test/", r.URL.String()) 1899 1900 // assert headers 1901 1902} 1903 1904func TestInputService6ProtocolTestListWithLocationNameAndQueryNameCase1(t *testing.T) { 1905 svc := NewInputService6ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 1906 input := &InputService6TestShapeInputService6TestCaseOperation1Input{ 1907 ListArg: []*string{ 1908 aws.String("a"), 1909 aws.String("b"), 1910 aws.String("c"), 1911 }, 1912 } 1913 req, _ := svc.InputService6TestCaseOperation1Request(input) 1914 r := req.HTTPRequest 1915 1916 // build request 1917 ec2query.Build(req) 1918 if req.Error != nil { 1919 t.Errorf("expect no error, got %v", req.Error) 1920 } 1921 1922 // assert body 1923 if r.Body == nil { 1924 t.Errorf("expect body not to be nil") 1925 } 1926 body, _ := ioutil.ReadAll(r.Body) 1927 awstesting.AssertQuery(t, `Action=OperationName&ListQueryName.1=a&ListQueryName.2=b&ListQueryName.3=c&Version=2014-01-01`, util.Trim(string(body))) 1928 1929 // assert URL 1930 awstesting.AssertURL(t, "https://test/", r.URL.String()) 1931 1932 // assert headers 1933 1934} 1935 1936func TestInputService7ProtocolTestBase64EncodedBlobsCase1(t *testing.T) { 1937 svc := NewInputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 1938 input := &InputService7TestShapeInputService7TestCaseOperation1Input{ 1939 BlobArg: []byte("foo"), 1940 } 1941 req, _ := svc.InputService7TestCaseOperation1Request(input) 1942 r := req.HTTPRequest 1943 1944 // build request 1945 ec2query.Build(req) 1946 if req.Error != nil { 1947 t.Errorf("expect no error, got %v", req.Error) 1948 } 1949 1950 // assert body 1951 if r.Body == nil { 1952 t.Errorf("expect body not to be nil") 1953 } 1954 body, _ := ioutil.ReadAll(r.Body) 1955 awstesting.AssertQuery(t, `Action=OperationName&BlobArg=Zm9v&Version=2014-01-01`, util.Trim(string(body))) 1956 1957 // assert URL 1958 awstesting.AssertURL(t, "https://test/", r.URL.String()) 1959 1960 // assert headers 1961 1962} 1963 1964func TestInputService8ProtocolTestTimestampValuesCase1(t *testing.T) { 1965 svc := NewInputService8ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 1966 input := &InputService8TestShapeInputService8TestCaseOperation1Input{ 1967 TimeArg: aws.Time(time.Unix(1422172800, 0)), 1968 } 1969 req, _ := svc.InputService8TestCaseOperation1Request(input) 1970 r := req.HTTPRequest 1971 1972 // build request 1973 ec2query.Build(req) 1974 if req.Error != nil { 1975 t.Errorf("expect no error, got %v", req.Error) 1976 } 1977 1978 // assert body 1979 if r.Body == nil { 1980 t.Errorf("expect body not to be nil") 1981 } 1982 body, _ := ioutil.ReadAll(r.Body) 1983 awstesting.AssertQuery(t, `Action=OperationName&TimeArg=2015-01-25T08%3A00%3A00Z&Version=2014-01-01`, util.Trim(string(body))) 1984 1985 // assert URL 1986 awstesting.AssertURL(t, "https://test/", r.URL.String()) 1987 1988 // assert headers 1989 1990} 1991 1992func TestInputService9ProtocolTestIdempotencyTokenAutoFillCase1(t *testing.T) { 1993 svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 1994 input := &InputService9TestShapeInputService9TestCaseOperation2Input{ 1995 Token: aws.String("abc123"), 1996 } 1997 req, _ := svc.InputService9TestCaseOperation1Request(input) 1998 r := req.HTTPRequest 1999 2000 // build request 2001 ec2query.Build(req) 2002 if req.Error != nil { 2003 t.Errorf("expect no error, got %v", req.Error) 2004 } 2005 2006 // assert body 2007 if r.Body == nil { 2008 t.Errorf("expect body not to be nil") 2009 } 2010 body, _ := ioutil.ReadAll(r.Body) 2011 awstesting.AssertQuery(t, `Action=OperationName&Token=abc123&Version=2014-01-01`, util.Trim(string(body))) 2012 2013 // assert URL 2014 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2015 2016 // assert headers 2017 2018} 2019 2020func TestInputService9ProtocolTestIdempotencyTokenAutoFillCase2(t *testing.T) { 2021 svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2022 input := &InputService9TestShapeInputService9TestCaseOperation2Input{} 2023 req, _ := svc.InputService9TestCaseOperation2Request(input) 2024 r := req.HTTPRequest 2025 2026 // build request 2027 ec2query.Build(req) 2028 if req.Error != nil { 2029 t.Errorf("expect no error, got %v", req.Error) 2030 } 2031 2032 // assert body 2033 if r.Body == nil { 2034 t.Errorf("expect body not to be nil") 2035 } 2036 body, _ := ioutil.ReadAll(r.Body) 2037 awstesting.AssertQuery(t, `Action=OperationName&Token=00000000-0000-4000-8000-000000000000&Version=2014-01-01`, util.Trim(string(body))) 2038 2039 // assert URL 2040 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2041 2042 // assert headers 2043 2044} 2045 2046func TestInputService10ProtocolTestEnumCase1(t *testing.T) { 2047 svc := NewInputService10ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2048 input := &InputService10TestShapeInputService10TestCaseOperation2Input{ 2049 ListEnums: []*string{ 2050 aws.String("foo"), 2051 aws.String(""), 2052 aws.String("bar"), 2053 }, 2054 } 2055 req, _ := svc.InputService10TestCaseOperation1Request(input) 2056 r := req.HTTPRequest 2057 2058 // build request 2059 ec2query.Build(req) 2060 if req.Error != nil { 2061 t.Errorf("expect no error, got %v", req.Error) 2062 } 2063 2064 // assert body 2065 if r.Body == nil { 2066 t.Errorf("expect body not to be nil") 2067 } 2068 body, _ := ioutil.ReadAll(r.Body) 2069 awstesting.AssertQuery(t, `Action=OperationName&ListEnums.1=foo&ListEnums.2=&ListEnums.3=bar&Version=2014-01-01`, util.Trim(string(body))) 2070 2071 // assert URL 2072 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2073 2074 // assert headers 2075 2076} 2077 2078func TestInputService10ProtocolTestEnumCase2(t *testing.T) { 2079 svc := NewInputService10ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2080 input := &InputService10TestShapeInputService10TestCaseOperation2Input{} 2081 req, _ := svc.InputService10TestCaseOperation2Request(input) 2082 r := req.HTTPRequest 2083 2084 // build request 2085 ec2query.Build(req) 2086 if req.Error != nil { 2087 t.Errorf("expect no error, got %v", req.Error) 2088 } 2089 2090 // assert body 2091 if r.Body == nil { 2092 t.Errorf("expect body not to be nil") 2093 } 2094 body, _ := ioutil.ReadAll(r.Body) 2095 awstesting.AssertQuery(t, `Action=OperationName&Version=2014-01-01`, util.Trim(string(body))) 2096 2097 // assert URL 2098 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2099 2100 // assert headers 2101 2102} 2103