1// Code generated by models/protocol_tests/generate.go. DO NOT EDIT. 2 3package ec2query_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/ec2query" 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(ec2query.BuildHandler) 94 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 95 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 96 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.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(ec2query.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 178type InputService1TestShapeInputService1TestCaseOperation1Input struct { 179 _ struct{} `type:"structure"` 180 181 Bar *string `type:"string"` 182 183 Foo *string `type:"string"` 184} 185 186// SetBar sets the Bar field's value. 187func (s *InputService1TestShapeInputService1TestCaseOperation1Input) SetBar(v string) *InputService1TestShapeInputService1TestCaseOperation1Input { 188 s.Bar = &v 189 return s 190} 191 192// SetFoo sets the Foo field's value. 193func (s *InputService1TestShapeInputService1TestCaseOperation1Input) SetFoo(v string) *InputService1TestShapeInputService1TestCaseOperation1Input { 194 s.Foo = &v 195 return s 196} 197 198type InputService1TestShapeInputService1TestCaseOperation1Output struct { 199 _ struct{} `type:"structure"` 200} 201 202// InputService2ProtocolTest provides the API operation methods for making requests to 203// . See this package's package overview docs 204// for details on the service. 205// 206// InputService2ProtocolTest methods are safe to use concurrently. It is not safe to 207// modify mutate any of the struct's properties though. 208type InputService2ProtocolTest struct { 209 *client.Client 210} 211 212// New creates a new instance of the InputService2ProtocolTest client with a session. 213// If additional configuration is needed for the client instance use the optional 214// aws.Config parameter to add your extra config. 215// 216// Example: 217// // Create a InputService2ProtocolTest client from just a session. 218// svc := inputservice2protocoltest.New(mySession) 219// 220// // Create a InputService2ProtocolTest client with additional configuration 221// svc := inputservice2protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 222func NewInputService2ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService2ProtocolTest { 223 c := p.ClientConfig("inputservice2protocoltest", cfgs...) 224 return newInputService2ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 225} 226 227// newClient creates, initializes and returns a new service client instance. 228func newInputService2ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService2ProtocolTest { 229 svc := &InputService2ProtocolTest{ 230 Client: client.New( 231 cfg, 232 metadata.ClientInfo{ 233 ServiceName: "InputService2ProtocolTest", 234 ServiceID: "InputService2ProtocolTest", 235 SigningName: signingName, 236 SigningRegion: signingRegion, 237 Endpoint: endpoint, 238 APIVersion: "2014-01-01", 239 }, 240 handlers, 241 ), 242 } 243 244 // Handlers 245 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 246 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 247 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 248 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 249 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 250 251 return svc 252} 253 254// newRequest creates a new request for a InputService2ProtocolTest operation and runs any 255// custom request initialization. 256func (c *InputService2ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 257 req := c.NewRequest(op, params, data) 258 259 return req 260} 261 262const opInputService2TestCaseOperation1 = "OperationName" 263 264// InputService2TestCaseOperation1Request generates a "aws/request.Request" representing the 265// client's request for the InputService2TestCaseOperation1 operation. The "output" return 266// value will be populated with the request's response once the request completes 267// successfully. 268// 269// Use "Send" method on the returned Request to send the API call to the service. 270// the "output" return value is not valid until after Send returns without error. 271// 272// See InputService2TestCaseOperation1 for more information on using the InputService2TestCaseOperation1 273// API call, and error handling. 274// 275// This method is useful when you want to inject custom logic or configuration 276// into the SDK's request lifecycle. Such as custom headers, or retry logic. 277// 278// 279// // Example sending a request using the InputService2TestCaseOperation1Request method. 280// req, resp := client.InputService2TestCaseOperation1Request(params) 281// 282// err := req.Send() 283// if err == nil { // resp is now filled 284// fmt.Println(resp) 285// } 286func (c *InputService2ProtocolTest) InputService2TestCaseOperation1Request(input *InputService2TestShapeInputService2TestCaseOperation1Input) (req *request.Request, output *InputService2TestShapeInputService2TestCaseOperation1Output) { 287 op := &request.Operation{ 288 Name: opInputService2TestCaseOperation1, 289 HTTPPath: "/", 290 } 291 292 if input == nil { 293 input = &InputService2TestShapeInputService2TestCaseOperation1Input{} 294 } 295 296 output = &InputService2TestShapeInputService2TestCaseOperation1Output{} 297 req = c.newRequest(op, input, output) 298 req.Handlers.Unmarshal.Swap(ec2query.UnmarshalHandler.Name, 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// successfully. 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.Swap(ec2query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 460 return 461} 462 463// InputService3TestCaseOperation1 API operation for . 464// 465// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 466// with awserr.Error's Code and Message methods to get detailed information about 467// the error. 468// 469// See the AWS API reference guide for 's 470// API operation InputService3TestCaseOperation1 for usage and error information. 471func (c *InputService3ProtocolTest) InputService3TestCaseOperation1(input *InputService3TestShapeInputService3TestCaseOperation1Input) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) { 472 req, out := c.InputService3TestCaseOperation1Request(input) 473 return out, req.Send() 474} 475 476// InputService3TestCaseOperation1WithContext is the same as InputService3TestCaseOperation1 with the addition of 477// the ability to pass a context and additional request options. 478// 479// See InputService3TestCaseOperation1 for details on how to use this API operation. 480// 481// The context must be non-nil and will be used for request cancellation. If 482// the context is nil a panic will occur. In the future the SDK may create 483// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 484// for more information on using Contexts. 485func (c *InputService3ProtocolTest) InputService3TestCaseOperation1WithContext(ctx aws.Context, input *InputService3TestShapeInputService3TestCaseOperation1Input, opts ...request.Option) (*InputService3TestShapeInputService3TestCaseOperation1Output, error) { 486 req, out := c.InputService3TestCaseOperation1Request(input) 487 req.SetContext(ctx) 488 req.ApplyOptions(opts...) 489 return out, req.Send() 490} 491 492type InputService3TestShapeInputService3TestCaseOperation1Input struct { 493 _ struct{} `type:"structure"` 494 495 StructArg *InputService3TestShapeStructType `locationName:"Struct" type:"structure"` 496} 497 498// SetStructArg sets the StructArg field's value. 499func (s *InputService3TestShapeInputService3TestCaseOperation1Input) SetStructArg(v *InputService3TestShapeStructType) *InputService3TestShapeInputService3TestCaseOperation1Input { 500 s.StructArg = v 501 return s 502} 503 504type InputService3TestShapeInputService3TestCaseOperation1Output struct { 505 _ struct{} `type:"structure"` 506} 507 508type InputService3TestShapeStructType struct { 509 _ struct{} `type:"structure"` 510 511 ScalarArg *string `locationName:"Scalar" type:"string"` 512} 513 514// SetScalarArg sets the ScalarArg field's value. 515func (s *InputService3TestShapeStructType) SetScalarArg(v string) *InputService3TestShapeStructType { 516 s.ScalarArg = &v 517 return s 518} 519 520// InputService4ProtocolTest provides the API operation methods for making requests to 521// . See this package's package overview docs 522// for details on the service. 523// 524// InputService4ProtocolTest methods are safe to use concurrently. It is not safe to 525// modify mutate any of the struct's properties though. 526type InputService4ProtocolTest struct { 527 *client.Client 528} 529 530// New creates a new instance of the InputService4ProtocolTest client with a session. 531// If additional configuration is needed for the client instance use the optional 532// aws.Config parameter to add your extra config. 533// 534// Example: 535// // Create a InputService4ProtocolTest client from just a session. 536// svc := inputservice4protocoltest.New(mySession) 537// 538// // Create a InputService4ProtocolTest client with additional configuration 539// svc := inputservice4protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 540func NewInputService4ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService4ProtocolTest { 541 c := p.ClientConfig("inputservice4protocoltest", cfgs...) 542 return newInputService4ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 543} 544 545// newClient creates, initializes and returns a new service client instance. 546func newInputService4ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService4ProtocolTest { 547 svc := &InputService4ProtocolTest{ 548 Client: client.New( 549 cfg, 550 metadata.ClientInfo{ 551 ServiceName: "InputService4ProtocolTest", 552 ServiceID: "InputService4ProtocolTest", 553 SigningName: signingName, 554 SigningRegion: signingRegion, 555 Endpoint: endpoint, 556 APIVersion: "2014-01-01", 557 }, 558 handlers, 559 ), 560 } 561 562 // Handlers 563 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 564 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 565 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 566 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 567 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 568 569 return svc 570} 571 572// newRequest creates a new request for a InputService4ProtocolTest operation and runs any 573// custom request initialization. 574func (c *InputService4ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 575 req := c.NewRequest(op, params, data) 576 577 return req 578} 579 580const opInputService4TestCaseOperation1 = "OperationName" 581 582// InputService4TestCaseOperation1Request generates a "aws/request.Request" representing the 583// client's request for the InputService4TestCaseOperation1 operation. The "output" return 584// value will be populated with the request's response once the request completes 585// successfully. 586// 587// Use "Send" method on the returned Request to send the API call to the service. 588// the "output" return value is not valid until after Send returns without error. 589// 590// See InputService4TestCaseOperation1 for more information on using the InputService4TestCaseOperation1 591// API call, and error handling. 592// 593// This method is useful when you want to inject custom logic or configuration 594// into the SDK's request lifecycle. Such as custom headers, or retry logic. 595// 596// 597// // Example sending a request using the InputService4TestCaseOperation1Request method. 598// req, resp := client.InputService4TestCaseOperation1Request(params) 599// 600// err := req.Send() 601// if err == nil { // resp is now filled 602// fmt.Println(resp) 603// } 604func (c *InputService4ProtocolTest) InputService4TestCaseOperation1Request(input *InputService4TestShapeInputService4TestCaseOperation1Input) (req *request.Request, output *InputService4TestShapeInputService4TestCaseOperation1Output) { 605 op := &request.Operation{ 606 Name: opInputService4TestCaseOperation1, 607 HTTPPath: "/", 608 } 609 610 if input == nil { 611 input = &InputService4TestShapeInputService4TestCaseOperation1Input{} 612 } 613 614 output = &InputService4TestShapeInputService4TestCaseOperation1Output{} 615 req = c.newRequest(op, input, output) 616 req.Handlers.Unmarshal.Swap(ec2query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 617 return 618} 619 620// InputService4TestCaseOperation1 API operation for . 621// 622// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 623// with awserr.Error's Code and Message methods to get detailed information about 624// the error. 625// 626// See the AWS API reference guide for 's 627// API operation InputService4TestCaseOperation1 for usage and error information. 628func (c *InputService4ProtocolTest) InputService4TestCaseOperation1(input *InputService4TestShapeInputService4TestCaseOperation1Input) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) { 629 req, out := c.InputService4TestCaseOperation1Request(input) 630 return out, req.Send() 631} 632 633// InputService4TestCaseOperation1WithContext is the same as InputService4TestCaseOperation1 with the addition of 634// the ability to pass a context and additional request options. 635// 636// See InputService4TestCaseOperation1 for details on how to use this API operation. 637// 638// The context must be non-nil and will be used for request cancellation. If 639// the context is nil a panic will occur. In the future the SDK may create 640// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 641// for more information on using Contexts. 642func (c *InputService4ProtocolTest) InputService4TestCaseOperation1WithContext(ctx aws.Context, input *InputService4TestShapeInputService4TestCaseOperation1Input, opts ...request.Option) (*InputService4TestShapeInputService4TestCaseOperation1Output, error) { 643 req, out := c.InputService4TestCaseOperation1Request(input) 644 req.SetContext(ctx) 645 req.ApplyOptions(opts...) 646 return out, req.Send() 647} 648 649type InputService4TestShapeInputService4TestCaseOperation1Input struct { 650 _ struct{} `type:"structure"` 651 652 ListBools []*bool `type:"list"` 653 654 ListFloats []*float64 `type:"list"` 655 656 ListIntegers []*int64 `type:"list"` 657 658 ListStrings []*string `type:"list"` 659} 660 661// SetListBools sets the ListBools field's value. 662func (s *InputService4TestShapeInputService4TestCaseOperation1Input) SetListBools(v []*bool) *InputService4TestShapeInputService4TestCaseOperation1Input { 663 s.ListBools = v 664 return s 665} 666 667// SetListFloats sets the ListFloats field's value. 668func (s *InputService4TestShapeInputService4TestCaseOperation1Input) SetListFloats(v []*float64) *InputService4TestShapeInputService4TestCaseOperation1Input { 669 s.ListFloats = v 670 return s 671} 672 673// SetListIntegers sets the ListIntegers field's value. 674func (s *InputService4TestShapeInputService4TestCaseOperation1Input) SetListIntegers(v []*int64) *InputService4TestShapeInputService4TestCaseOperation1Input { 675 s.ListIntegers = v 676 return s 677} 678 679// SetListStrings sets the ListStrings field's value. 680func (s *InputService4TestShapeInputService4TestCaseOperation1Input) SetListStrings(v []*string) *InputService4TestShapeInputService4TestCaseOperation1Input { 681 s.ListStrings = v 682 return s 683} 684 685type InputService4TestShapeInputService4TestCaseOperation1Output struct { 686 _ struct{} `type:"structure"` 687} 688 689// InputService5ProtocolTest provides the API operation methods for making requests to 690// . See this package's package overview docs 691// for details on the service. 692// 693// InputService5ProtocolTest methods are safe to use concurrently. It is not safe to 694// modify mutate any of the struct's properties though. 695type InputService5ProtocolTest struct { 696 *client.Client 697} 698 699// New creates a new instance of the InputService5ProtocolTest client with a session. 700// If additional configuration is needed for the client instance use the optional 701// aws.Config parameter to add your extra config. 702// 703// Example: 704// // Create a InputService5ProtocolTest client from just a session. 705// svc := inputservice5protocoltest.New(mySession) 706// 707// // Create a InputService5ProtocolTest client with additional configuration 708// svc := inputservice5protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 709func NewInputService5ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService5ProtocolTest { 710 c := p.ClientConfig("inputservice5protocoltest", cfgs...) 711 return newInputService5ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 712} 713 714// newClient creates, initializes and returns a new service client instance. 715func newInputService5ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService5ProtocolTest { 716 svc := &InputService5ProtocolTest{ 717 Client: client.New( 718 cfg, 719 metadata.ClientInfo{ 720 ServiceName: "InputService5ProtocolTest", 721 ServiceID: "InputService5ProtocolTest", 722 SigningName: signingName, 723 SigningRegion: signingRegion, 724 Endpoint: endpoint, 725 APIVersion: "2014-01-01", 726 }, 727 handlers, 728 ), 729 } 730 731 // Handlers 732 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 733 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 734 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 735 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 736 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 737 738 return svc 739} 740 741// newRequest creates a new request for a InputService5ProtocolTest operation and runs any 742// custom request initialization. 743func (c *InputService5ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 744 req := c.NewRequest(op, params, data) 745 746 return req 747} 748 749const opInputService5TestCaseOperation1 = "OperationName" 750 751// InputService5TestCaseOperation1Request generates a "aws/request.Request" representing the 752// client's request for the InputService5TestCaseOperation1 operation. The "output" return 753// value will be populated with the request's response once the request completes 754// successfully. 755// 756// Use "Send" method on the returned Request to send the API call to the service. 757// the "output" return value is not valid until after Send returns without error. 758// 759// See InputService5TestCaseOperation1 for more information on using the InputService5TestCaseOperation1 760// API call, and error handling. 761// 762// This method is useful when you want to inject custom logic or configuration 763// into the SDK's request lifecycle. Such as custom headers, or retry logic. 764// 765// 766// // Example sending a request using the InputService5TestCaseOperation1Request method. 767// req, resp := client.InputService5TestCaseOperation1Request(params) 768// 769// err := req.Send() 770// if err == nil { // resp is now filled 771// fmt.Println(resp) 772// } 773func (c *InputService5ProtocolTest) InputService5TestCaseOperation1Request(input *InputService5TestShapeInputService5TestCaseOperation1Input) (req *request.Request, output *InputService5TestShapeInputService5TestCaseOperation1Output) { 774 op := &request.Operation{ 775 Name: opInputService5TestCaseOperation1, 776 HTTPPath: "/", 777 } 778 779 if input == nil { 780 input = &InputService5TestShapeInputService5TestCaseOperation1Input{} 781 } 782 783 output = &InputService5TestShapeInputService5TestCaseOperation1Output{} 784 req = c.newRequest(op, input, output) 785 req.Handlers.Unmarshal.Swap(ec2query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 786 return 787} 788 789// InputService5TestCaseOperation1 API operation for . 790// 791// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 792// with awserr.Error's Code and Message methods to get detailed information about 793// the error. 794// 795// See the AWS API reference guide for 's 796// API operation InputService5TestCaseOperation1 for usage and error information. 797func (c *InputService5ProtocolTest) InputService5TestCaseOperation1(input *InputService5TestShapeInputService5TestCaseOperation1Input) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) { 798 req, out := c.InputService5TestCaseOperation1Request(input) 799 return out, req.Send() 800} 801 802// InputService5TestCaseOperation1WithContext is the same as InputService5TestCaseOperation1 with the addition of 803// the ability to pass a context and additional request options. 804// 805// See InputService5TestCaseOperation1 for details on how to use this API operation. 806// 807// The context must be non-nil and will be used for request cancellation. If 808// the context is nil a panic will occur. In the future the SDK may create 809// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 810// for more information on using Contexts. 811func (c *InputService5ProtocolTest) InputService5TestCaseOperation1WithContext(ctx aws.Context, input *InputService5TestShapeInputService5TestCaseOperation1Input, opts ...request.Option) (*InputService5TestShapeInputService5TestCaseOperation1Output, error) { 812 req, out := c.InputService5TestCaseOperation1Request(input) 813 req.SetContext(ctx) 814 req.ApplyOptions(opts...) 815 return out, req.Send() 816} 817 818type InputService5TestShapeInputService5TestCaseOperation1Input struct { 819 _ struct{} `type:"structure"` 820 821 ListArg []*string `locationName:"ListMemberName" locationNameList:"item" type:"list"` 822} 823 824// SetListArg sets the ListArg field's value. 825func (s *InputService5TestShapeInputService5TestCaseOperation1Input) SetListArg(v []*string) *InputService5TestShapeInputService5TestCaseOperation1Input { 826 s.ListArg = v 827 return s 828} 829 830type InputService5TestShapeInputService5TestCaseOperation1Output struct { 831 _ struct{} `type:"structure"` 832} 833 834// InputService6ProtocolTest provides the API operation methods for making requests to 835// . See this package's package overview docs 836// for details on the service. 837// 838// InputService6ProtocolTest methods are safe to use concurrently. It is not safe to 839// modify mutate any of the struct's properties though. 840type InputService6ProtocolTest struct { 841 *client.Client 842} 843 844// New creates a new instance of the InputService6ProtocolTest client with a session. 845// If additional configuration is needed for the client instance use the optional 846// aws.Config parameter to add your extra config. 847// 848// Example: 849// // Create a InputService6ProtocolTest client from just a session. 850// svc := inputservice6protocoltest.New(mySession) 851// 852// // Create a InputService6ProtocolTest client with additional configuration 853// svc := inputservice6protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 854func NewInputService6ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService6ProtocolTest { 855 c := p.ClientConfig("inputservice6protocoltest", cfgs...) 856 return newInputService6ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 857} 858 859// newClient creates, initializes and returns a new service client instance. 860func newInputService6ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService6ProtocolTest { 861 svc := &InputService6ProtocolTest{ 862 Client: client.New( 863 cfg, 864 metadata.ClientInfo{ 865 ServiceName: "InputService6ProtocolTest", 866 ServiceID: "InputService6ProtocolTest", 867 SigningName: signingName, 868 SigningRegion: signingRegion, 869 Endpoint: endpoint, 870 APIVersion: "2014-01-01", 871 }, 872 handlers, 873 ), 874 } 875 876 // Handlers 877 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 878 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 879 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 880 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 881 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 882 883 return svc 884} 885 886// newRequest creates a new request for a InputService6ProtocolTest operation and runs any 887// custom request initialization. 888func (c *InputService6ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 889 req := c.NewRequest(op, params, data) 890 891 return req 892} 893 894const opInputService6TestCaseOperation1 = "OperationName" 895 896// InputService6TestCaseOperation1Request generates a "aws/request.Request" representing the 897// client's request for the InputService6TestCaseOperation1 operation. The "output" return 898// value will be populated with the request's response once the request completes 899// successfully. 900// 901// Use "Send" method on the returned Request to send the API call to the service. 902// the "output" return value is not valid until after Send returns without error. 903// 904// See InputService6TestCaseOperation1 for more information on using the InputService6TestCaseOperation1 905// API call, and error handling. 906// 907// This method is useful when you want to inject custom logic or configuration 908// into the SDK's request lifecycle. Such as custom headers, or retry logic. 909// 910// 911// // Example sending a request using the InputService6TestCaseOperation1Request method. 912// req, resp := client.InputService6TestCaseOperation1Request(params) 913// 914// err := req.Send() 915// if err == nil { // resp is now filled 916// fmt.Println(resp) 917// } 918func (c *InputService6ProtocolTest) InputService6TestCaseOperation1Request(input *InputService6TestShapeInputService6TestCaseOperation1Input) (req *request.Request, output *InputService6TestShapeInputService6TestCaseOperation1Output) { 919 op := &request.Operation{ 920 Name: opInputService6TestCaseOperation1, 921 HTTPPath: "/", 922 } 923 924 if input == nil { 925 input = &InputService6TestShapeInputService6TestCaseOperation1Input{} 926 } 927 928 output = &InputService6TestShapeInputService6TestCaseOperation1Output{} 929 req = c.newRequest(op, input, output) 930 req.Handlers.Unmarshal.Swap(ec2query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 931 return 932} 933 934// InputService6TestCaseOperation1 API operation for . 935// 936// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 937// with awserr.Error's Code and Message methods to get detailed information about 938// the error. 939// 940// See the AWS API reference guide for 's 941// API operation InputService6TestCaseOperation1 for usage and error information. 942func (c *InputService6ProtocolTest) InputService6TestCaseOperation1(input *InputService6TestShapeInputService6TestCaseOperation1Input) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) { 943 req, out := c.InputService6TestCaseOperation1Request(input) 944 return out, req.Send() 945} 946 947// InputService6TestCaseOperation1WithContext is the same as InputService6TestCaseOperation1 with the addition of 948// the ability to pass a context and additional request options. 949// 950// See InputService6TestCaseOperation1 for details on how to use this API operation. 951// 952// The context must be non-nil and will be used for request cancellation. If 953// the context is nil a panic will occur. In the future the SDK may create 954// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 955// for more information on using Contexts. 956func (c *InputService6ProtocolTest) InputService6TestCaseOperation1WithContext(ctx aws.Context, input *InputService6TestShapeInputService6TestCaseOperation1Input, opts ...request.Option) (*InputService6TestShapeInputService6TestCaseOperation1Output, error) { 957 req, out := c.InputService6TestCaseOperation1Request(input) 958 req.SetContext(ctx) 959 req.ApplyOptions(opts...) 960 return out, req.Send() 961} 962 963type InputService6TestShapeInputService6TestCaseOperation1Input struct { 964 _ struct{} `type:"structure"` 965 966 ListArg []*string `locationName:"ListMemberName" queryName:"ListQueryName" locationNameList:"item" type:"list"` 967} 968 969// SetListArg sets the ListArg field's value. 970func (s *InputService6TestShapeInputService6TestCaseOperation1Input) SetListArg(v []*string) *InputService6TestShapeInputService6TestCaseOperation1Input { 971 s.ListArg = v 972 return s 973} 974 975type InputService6TestShapeInputService6TestCaseOperation1Output struct { 976 _ struct{} `type:"structure"` 977} 978 979// InputService7ProtocolTest provides the API operation methods for making requests to 980// . See this package's package overview docs 981// for details on the service. 982// 983// InputService7ProtocolTest methods are safe to use concurrently. It is not safe to 984// modify mutate any of the struct's properties though. 985type InputService7ProtocolTest struct { 986 *client.Client 987} 988 989// New creates a new instance of the InputService7ProtocolTest client with a session. 990// If additional configuration is needed for the client instance use the optional 991// aws.Config parameter to add your extra config. 992// 993// Example: 994// // Create a InputService7ProtocolTest client from just a session. 995// svc := inputservice7protocoltest.New(mySession) 996// 997// // Create a InputService7ProtocolTest client with additional configuration 998// svc := inputservice7protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 999func NewInputService7ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService7ProtocolTest { 1000 c := p.ClientConfig("inputservice7protocoltest", cfgs...) 1001 return newInputService7ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1002} 1003 1004// newClient creates, initializes and returns a new service client instance. 1005func newInputService7ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService7ProtocolTest { 1006 svc := &InputService7ProtocolTest{ 1007 Client: client.New( 1008 cfg, 1009 metadata.ClientInfo{ 1010 ServiceName: "InputService7ProtocolTest", 1011 ServiceID: "InputService7ProtocolTest", 1012 SigningName: signingName, 1013 SigningRegion: signingRegion, 1014 Endpoint: endpoint, 1015 APIVersion: "2014-01-01", 1016 }, 1017 handlers, 1018 ), 1019 } 1020 1021 // Handlers 1022 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1023 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 1024 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 1025 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 1026 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 1027 1028 return svc 1029} 1030 1031// newRequest creates a new request for a InputService7ProtocolTest operation and runs any 1032// custom request initialization. 1033func (c *InputService7ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1034 req := c.NewRequest(op, params, data) 1035 1036 return req 1037} 1038 1039const opInputService7TestCaseOperation1 = "OperationName" 1040 1041// InputService7TestCaseOperation1Request generates a "aws/request.Request" representing the 1042// client's request for the InputService7TestCaseOperation1 operation. The "output" return 1043// value will be populated with the request's response once the request completes 1044// successfully. 1045// 1046// Use "Send" method on the returned Request to send the API call to the service. 1047// the "output" return value is not valid until after Send returns without error. 1048// 1049// See InputService7TestCaseOperation1 for more information on using the InputService7TestCaseOperation1 1050// API call, and error handling. 1051// 1052// This method is useful when you want to inject custom logic or configuration 1053// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1054// 1055// 1056// // Example sending a request using the InputService7TestCaseOperation1Request method. 1057// req, resp := client.InputService7TestCaseOperation1Request(params) 1058// 1059// err := req.Send() 1060// if err == nil { // resp is now filled 1061// fmt.Println(resp) 1062// } 1063func (c *InputService7ProtocolTest) InputService7TestCaseOperation1Request(input *InputService7TestShapeInputService7TestCaseOperation1Input) (req *request.Request, output *InputService7TestShapeInputService7TestCaseOperation1Output) { 1064 op := &request.Operation{ 1065 Name: opInputService7TestCaseOperation1, 1066 HTTPPath: "/", 1067 } 1068 1069 if input == nil { 1070 input = &InputService7TestShapeInputService7TestCaseOperation1Input{} 1071 } 1072 1073 output = &InputService7TestShapeInputService7TestCaseOperation1Output{} 1074 req = c.newRequest(op, input, output) 1075 req.Handlers.Unmarshal.Swap(ec2query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1076 return 1077} 1078 1079// InputService7TestCaseOperation1 API operation for . 1080// 1081// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1082// with awserr.Error's Code and Message methods to get detailed information about 1083// the error. 1084// 1085// See the AWS API reference guide for 's 1086// API operation InputService7TestCaseOperation1 for usage and error information. 1087func (c *InputService7ProtocolTest) InputService7TestCaseOperation1(input *InputService7TestShapeInputService7TestCaseOperation1Input) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) { 1088 req, out := c.InputService7TestCaseOperation1Request(input) 1089 return out, req.Send() 1090} 1091 1092// InputService7TestCaseOperation1WithContext is the same as InputService7TestCaseOperation1 with the addition of 1093// the ability to pass a context and additional request options. 1094// 1095// See InputService7TestCaseOperation1 for details on how to use this API operation. 1096// 1097// The context must be non-nil and will be used for request cancellation. If 1098// the context is nil a panic will occur. In the future the SDK may create 1099// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1100// for more information on using Contexts. 1101func (c *InputService7ProtocolTest) InputService7TestCaseOperation1WithContext(ctx aws.Context, input *InputService7TestShapeInputService7TestCaseOperation1Input, opts ...request.Option) (*InputService7TestShapeInputService7TestCaseOperation1Output, error) { 1102 req, out := c.InputService7TestCaseOperation1Request(input) 1103 req.SetContext(ctx) 1104 req.ApplyOptions(opts...) 1105 return out, req.Send() 1106} 1107 1108type InputService7TestShapeInputService7TestCaseOperation1Input struct { 1109 _ struct{} `type:"structure"` 1110 1111 // BlobArg is automatically base64 encoded/decoded by the SDK. 1112 BlobArg []byte `type:"blob"` 1113} 1114 1115// SetBlobArg sets the BlobArg field's value. 1116func (s *InputService7TestShapeInputService7TestCaseOperation1Input) SetBlobArg(v []byte) *InputService7TestShapeInputService7TestCaseOperation1Input { 1117 s.BlobArg = v 1118 return s 1119} 1120 1121type InputService7TestShapeInputService7TestCaseOperation1Output struct { 1122 _ struct{} `type:"structure"` 1123} 1124 1125// InputService8ProtocolTest provides the API operation methods for making requests to 1126// . See this package's package overview docs 1127// for details on the service. 1128// 1129// InputService8ProtocolTest methods are safe to use concurrently. It is not safe to 1130// modify mutate any of the struct's properties though. 1131type InputService8ProtocolTest struct { 1132 *client.Client 1133} 1134 1135// New creates a new instance of the InputService8ProtocolTest client with a session. 1136// If additional configuration is needed for the client instance use the optional 1137// aws.Config parameter to add your extra config. 1138// 1139// Example: 1140// // Create a InputService8ProtocolTest client from just a session. 1141// svc := inputservice8protocoltest.New(mySession) 1142// 1143// // Create a InputService8ProtocolTest client with additional configuration 1144// svc := inputservice8protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1145func NewInputService8ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService8ProtocolTest { 1146 c := p.ClientConfig("inputservice8protocoltest", cfgs...) 1147 return newInputService8ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1148} 1149 1150// newClient creates, initializes and returns a new service client instance. 1151func newInputService8ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService8ProtocolTest { 1152 svc := &InputService8ProtocolTest{ 1153 Client: client.New( 1154 cfg, 1155 metadata.ClientInfo{ 1156 ServiceName: "InputService8ProtocolTest", 1157 ServiceID: "InputService8ProtocolTest", 1158 SigningName: signingName, 1159 SigningRegion: signingRegion, 1160 Endpoint: endpoint, 1161 APIVersion: "2014-01-01", 1162 }, 1163 handlers, 1164 ), 1165 } 1166 1167 // Handlers 1168 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1169 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 1170 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 1171 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 1172 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 1173 1174 return svc 1175} 1176 1177// newRequest creates a new request for a InputService8ProtocolTest operation and runs any 1178// custom request initialization. 1179func (c *InputService8ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1180 req := c.NewRequest(op, params, data) 1181 1182 return req 1183} 1184 1185const opInputService8TestCaseOperation1 = "OperationName" 1186 1187// InputService8TestCaseOperation1Request generates a "aws/request.Request" representing the 1188// client's request for the InputService8TestCaseOperation1 operation. The "output" return 1189// value will be populated with the request's response once the request completes 1190// successfully. 1191// 1192// Use "Send" method on the returned Request to send the API call to the service. 1193// the "output" return value is not valid until after Send returns without error. 1194// 1195// See InputService8TestCaseOperation1 for more information on using the InputService8TestCaseOperation1 1196// API call, and error handling. 1197// 1198// This method is useful when you want to inject custom logic or configuration 1199// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1200// 1201// 1202// // Example sending a request using the InputService8TestCaseOperation1Request method. 1203// req, resp := client.InputService8TestCaseOperation1Request(params) 1204// 1205// err := req.Send() 1206// if err == nil { // resp is now filled 1207// fmt.Println(resp) 1208// } 1209func (c *InputService8ProtocolTest) InputService8TestCaseOperation1Request(input *InputService8TestShapeInputService8TestCaseOperation1Input) (req *request.Request, output *InputService8TestShapeInputService8TestCaseOperation1Output) { 1210 op := &request.Operation{ 1211 Name: opInputService8TestCaseOperation1, 1212 HTTPPath: "/", 1213 } 1214 1215 if input == nil { 1216 input = &InputService8TestShapeInputService8TestCaseOperation1Input{} 1217 } 1218 1219 output = &InputService8TestShapeInputService8TestCaseOperation1Output{} 1220 req = c.newRequest(op, input, output) 1221 req.Handlers.Unmarshal.Swap(ec2query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1222 return 1223} 1224 1225// InputService8TestCaseOperation1 API operation for . 1226// 1227// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1228// with awserr.Error's Code and Message methods to get detailed information about 1229// the error. 1230// 1231// See the AWS API reference guide for 's 1232// API operation InputService8TestCaseOperation1 for usage and error information. 1233func (c *InputService8ProtocolTest) InputService8TestCaseOperation1(input *InputService8TestShapeInputService8TestCaseOperation1Input) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) { 1234 req, out := c.InputService8TestCaseOperation1Request(input) 1235 return out, req.Send() 1236} 1237 1238// InputService8TestCaseOperation1WithContext is the same as InputService8TestCaseOperation1 with the addition of 1239// the ability to pass a context and additional request options. 1240// 1241// See InputService8TestCaseOperation1 for details on how to use this API operation. 1242// 1243// The context must be non-nil and will be used for request cancellation. If 1244// the context is nil a panic will occur. In the future the SDK may create 1245// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1246// for more information on using Contexts. 1247func (c *InputService8ProtocolTest) InputService8TestCaseOperation1WithContext(ctx aws.Context, input *InputService8TestShapeInputService8TestCaseOperation1Input, opts ...request.Option) (*InputService8TestShapeInputService8TestCaseOperation1Output, error) { 1248 req, out := c.InputService8TestCaseOperation1Request(input) 1249 req.SetContext(ctx) 1250 req.ApplyOptions(opts...) 1251 return out, req.Send() 1252} 1253 1254type InputService8TestShapeInputService8TestCaseOperation1Input struct { 1255 _ struct{} `type:"structure"` 1256 1257 TimeArg *time.Time `type:"timestamp"` 1258 1259 TimeCustom *time.Time `type:"timestamp" timestampFormat:"unixTimestamp"` 1260 1261 TimeFormat *time.Time `type:"timestamp" timestampFormat:"unixTimestamp"` 1262} 1263 1264// SetTimeArg sets the TimeArg field's value. 1265func (s *InputService8TestShapeInputService8TestCaseOperation1Input) SetTimeArg(v time.Time) *InputService8TestShapeInputService8TestCaseOperation1Input { 1266 s.TimeArg = &v 1267 return s 1268} 1269 1270// SetTimeCustom sets the TimeCustom field's value. 1271func (s *InputService8TestShapeInputService8TestCaseOperation1Input) SetTimeCustom(v time.Time) *InputService8TestShapeInputService8TestCaseOperation1Input { 1272 s.TimeCustom = &v 1273 return s 1274} 1275 1276// SetTimeFormat sets the TimeFormat field's value. 1277func (s *InputService8TestShapeInputService8TestCaseOperation1Input) SetTimeFormat(v time.Time) *InputService8TestShapeInputService8TestCaseOperation1Input { 1278 s.TimeFormat = &v 1279 return s 1280} 1281 1282type InputService8TestShapeInputService8TestCaseOperation1Output struct { 1283 _ struct{} `type:"structure"` 1284} 1285 1286// InputService9ProtocolTest provides the API operation methods for making requests to 1287// . See this package's package overview docs 1288// for details on the service. 1289// 1290// InputService9ProtocolTest methods are safe to use concurrently. It is not safe to 1291// modify mutate any of the struct's properties though. 1292type InputService9ProtocolTest struct { 1293 *client.Client 1294} 1295 1296// New creates a new instance of the InputService9ProtocolTest client with a session. 1297// If additional configuration is needed for the client instance use the optional 1298// aws.Config parameter to add your extra config. 1299// 1300// Example: 1301// // Create a InputService9ProtocolTest client from just a session. 1302// svc := inputservice9protocoltest.New(mySession) 1303// 1304// // Create a InputService9ProtocolTest client with additional configuration 1305// svc := inputservice9protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1306func NewInputService9ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService9ProtocolTest { 1307 c := p.ClientConfig("inputservice9protocoltest", cfgs...) 1308 return newInputService9ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1309} 1310 1311// newClient creates, initializes and returns a new service client instance. 1312func newInputService9ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService9ProtocolTest { 1313 svc := &InputService9ProtocolTest{ 1314 Client: client.New( 1315 cfg, 1316 metadata.ClientInfo{ 1317 ServiceName: "InputService9ProtocolTest", 1318 ServiceID: "InputService9ProtocolTest", 1319 SigningName: signingName, 1320 SigningRegion: signingRegion, 1321 Endpoint: endpoint, 1322 APIVersion: "2014-01-01", 1323 }, 1324 handlers, 1325 ), 1326 } 1327 1328 // Handlers 1329 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1330 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 1331 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 1332 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 1333 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 1334 1335 return svc 1336} 1337 1338// newRequest creates a new request for a InputService9ProtocolTest operation and runs any 1339// custom request initialization. 1340func (c *InputService9ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1341 req := c.NewRequest(op, params, data) 1342 1343 return req 1344} 1345 1346const opInputService9TestCaseOperation1 = "OperationName" 1347 1348// InputService9TestCaseOperation1Request generates a "aws/request.Request" representing the 1349// client's request for the InputService9TestCaseOperation1 operation. The "output" return 1350// value will be populated with the request's response once the request completes 1351// successfully. 1352// 1353// Use "Send" method on the returned Request to send the API call to the service. 1354// the "output" return value is not valid until after Send returns without error. 1355// 1356// See InputService9TestCaseOperation1 for more information on using the InputService9TestCaseOperation1 1357// API call, and error handling. 1358// 1359// This method is useful when you want to inject custom logic or configuration 1360// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1361// 1362// 1363// // Example sending a request using the InputService9TestCaseOperation1Request method. 1364// req, resp := client.InputService9TestCaseOperation1Request(params) 1365// 1366// err := req.Send() 1367// if err == nil { // resp is now filled 1368// fmt.Println(resp) 1369// } 1370func (c *InputService9ProtocolTest) InputService9TestCaseOperation1Request(input *InputService9TestShapeInputService9TestCaseOperation1Input) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation1Output) { 1371 op := &request.Operation{ 1372 Name: opInputService9TestCaseOperation1, 1373 HTTPPath: "/", 1374 } 1375 1376 if input == nil { 1377 input = &InputService9TestShapeInputService9TestCaseOperation1Input{} 1378 } 1379 1380 output = &InputService9TestShapeInputService9TestCaseOperation1Output{} 1381 req = c.newRequest(op, input, output) 1382 req.Handlers.Unmarshal.Swap(ec2query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1383 return 1384} 1385 1386// InputService9TestCaseOperation1 API operation for . 1387// 1388// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1389// with awserr.Error's Code and Message methods to get detailed information about 1390// the error. 1391// 1392// See the AWS API reference guide for 's 1393// API operation InputService9TestCaseOperation1 for usage and error information. 1394func (c *InputService9ProtocolTest) InputService9TestCaseOperation1(input *InputService9TestShapeInputService9TestCaseOperation1Input) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) { 1395 req, out := c.InputService9TestCaseOperation1Request(input) 1396 return out, req.Send() 1397} 1398 1399// InputService9TestCaseOperation1WithContext is the same as InputService9TestCaseOperation1 with the addition of 1400// the ability to pass a context and additional request options. 1401// 1402// See InputService9TestCaseOperation1 for details on how to use this API operation. 1403// 1404// The context must be non-nil and will be used for request cancellation. If 1405// the context is nil a panic will occur. In the future the SDK may create 1406// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1407// for more information on using Contexts. 1408func (c *InputService9ProtocolTest) InputService9TestCaseOperation1WithContext(ctx aws.Context, input *InputService9TestShapeInputService9TestCaseOperation1Input, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation1Output, error) { 1409 req, out := c.InputService9TestCaseOperation1Request(input) 1410 req.SetContext(ctx) 1411 req.ApplyOptions(opts...) 1412 return out, req.Send() 1413} 1414 1415const opInputService9TestCaseOperation2 = "OperationName" 1416 1417// InputService9TestCaseOperation2Request generates a "aws/request.Request" representing the 1418// client's request for the InputService9TestCaseOperation2 operation. The "output" return 1419// value will be populated with the request's response once the request completes 1420// successfully. 1421// 1422// Use "Send" method on the returned Request to send the API call to the service. 1423// the "output" return value is not valid until after Send returns without error. 1424// 1425// See InputService9TestCaseOperation2 for more information on using the InputService9TestCaseOperation2 1426// API call, and error handling. 1427// 1428// This method is useful when you want to inject custom logic or configuration 1429// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1430// 1431// 1432// // Example sending a request using the InputService9TestCaseOperation2Request method. 1433// req, resp := client.InputService9TestCaseOperation2Request(params) 1434// 1435// err := req.Send() 1436// if err == nil { // resp is now filled 1437// fmt.Println(resp) 1438// } 1439func (c *InputService9ProtocolTest) InputService9TestCaseOperation2Request(input *InputService9TestShapeInputService9TestCaseOperation2Input) (req *request.Request, output *InputService9TestShapeInputService9TestCaseOperation2Output) { 1440 op := &request.Operation{ 1441 Name: opInputService9TestCaseOperation2, 1442 HTTPPath: "/", 1443 } 1444 1445 if input == nil { 1446 input = &InputService9TestShapeInputService9TestCaseOperation2Input{} 1447 } 1448 1449 output = &InputService9TestShapeInputService9TestCaseOperation2Output{} 1450 req = c.newRequest(op, input, output) 1451 req.Handlers.Unmarshal.Swap(ec2query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1452 return 1453} 1454 1455// InputService9TestCaseOperation2 API operation for . 1456// 1457// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1458// with awserr.Error's Code and Message methods to get detailed information about 1459// the error. 1460// 1461// See the AWS API reference guide for 's 1462// API operation InputService9TestCaseOperation2 for usage and error information. 1463func (c *InputService9ProtocolTest) InputService9TestCaseOperation2(input *InputService9TestShapeInputService9TestCaseOperation2Input) (*InputService9TestShapeInputService9TestCaseOperation2Output, error) { 1464 req, out := c.InputService9TestCaseOperation2Request(input) 1465 return out, req.Send() 1466} 1467 1468// InputService9TestCaseOperation2WithContext is the same as InputService9TestCaseOperation2 with the addition of 1469// the ability to pass a context and additional request options. 1470// 1471// See InputService9TestCaseOperation2 for details on how to use this API operation. 1472// 1473// The context must be non-nil and will be used for request cancellation. If 1474// the context is nil a panic will occur. In the future the SDK may create 1475// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1476// for more information on using Contexts. 1477func (c *InputService9ProtocolTest) InputService9TestCaseOperation2WithContext(ctx aws.Context, input *InputService9TestShapeInputService9TestCaseOperation2Input, opts ...request.Option) (*InputService9TestShapeInputService9TestCaseOperation2Output, error) { 1478 req, out := c.InputService9TestCaseOperation2Request(input) 1479 req.SetContext(ctx) 1480 req.ApplyOptions(opts...) 1481 return out, req.Send() 1482} 1483 1484type InputService9TestShapeInputService9TestCaseOperation1Input struct { 1485 _ struct{} `type:"structure"` 1486 1487 Token *string `type:"string" idempotencyToken:"true"` 1488} 1489 1490// SetToken sets the Token field's value. 1491func (s *InputService9TestShapeInputService9TestCaseOperation1Input) SetToken(v string) *InputService9TestShapeInputService9TestCaseOperation1Input { 1492 s.Token = &v 1493 return s 1494} 1495 1496type InputService9TestShapeInputService9TestCaseOperation1Output struct { 1497 _ struct{} `type:"structure"` 1498} 1499 1500type InputService9TestShapeInputService9TestCaseOperation2Input struct { 1501 _ struct{} `type:"structure"` 1502 1503 Token *string `type:"string" idempotencyToken:"true"` 1504} 1505 1506// SetToken sets the Token field's value. 1507func (s *InputService9TestShapeInputService9TestCaseOperation2Input) SetToken(v string) *InputService9TestShapeInputService9TestCaseOperation2Input { 1508 s.Token = &v 1509 return s 1510} 1511 1512type InputService9TestShapeInputService9TestCaseOperation2Output struct { 1513 _ struct{} `type:"structure"` 1514} 1515 1516// InputService10ProtocolTest provides the API operation methods for making requests to 1517// . See this package's package overview docs 1518// for details on the service. 1519// 1520// InputService10ProtocolTest methods are safe to use concurrently. It is not safe to 1521// modify mutate any of the struct's properties though. 1522type InputService10ProtocolTest struct { 1523 *client.Client 1524} 1525 1526// New creates a new instance of the InputService10ProtocolTest client with a session. 1527// If additional configuration is needed for the client instance use the optional 1528// aws.Config parameter to add your extra config. 1529// 1530// Example: 1531// // Create a InputService10ProtocolTest client from just a session. 1532// svc := inputservice10protocoltest.New(mySession) 1533// 1534// // Create a InputService10ProtocolTest client with additional configuration 1535// svc := inputservice10protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1536func NewInputService10ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService10ProtocolTest { 1537 c := p.ClientConfig("inputservice10protocoltest", cfgs...) 1538 return newInputService10ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1539} 1540 1541// newClient creates, initializes and returns a new service client instance. 1542func newInputService10ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService10ProtocolTest { 1543 svc := &InputService10ProtocolTest{ 1544 Client: client.New( 1545 cfg, 1546 metadata.ClientInfo{ 1547 ServiceName: "InputService10ProtocolTest", 1548 ServiceID: "InputService10ProtocolTest", 1549 SigningName: signingName, 1550 SigningRegion: signingRegion, 1551 Endpoint: endpoint, 1552 APIVersion: "2014-01-01", 1553 }, 1554 handlers, 1555 ), 1556 } 1557 1558 // Handlers 1559 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1560 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 1561 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 1562 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 1563 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 1564 1565 return svc 1566} 1567 1568// newRequest creates a new request for a InputService10ProtocolTest operation and runs any 1569// custom request initialization. 1570func (c *InputService10ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1571 req := c.NewRequest(op, params, data) 1572 1573 return req 1574} 1575 1576const opInputService10TestCaseOperation1 = "OperationName" 1577 1578// InputService10TestCaseOperation1Request generates a "aws/request.Request" representing the 1579// client's request for the InputService10TestCaseOperation1 operation. The "output" return 1580// value will be populated with the request's response once the request completes 1581// successfully. 1582// 1583// Use "Send" method on the returned Request to send the API call to the service. 1584// the "output" return value is not valid until after Send returns without error. 1585// 1586// See InputService10TestCaseOperation1 for more information on using the InputService10TestCaseOperation1 1587// API call, and error handling. 1588// 1589// This method is useful when you want to inject custom logic or configuration 1590// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1591// 1592// 1593// // Example sending a request using the InputService10TestCaseOperation1Request method. 1594// req, resp := client.InputService10TestCaseOperation1Request(params) 1595// 1596// err := req.Send() 1597// if err == nil { // resp is now filled 1598// fmt.Println(resp) 1599// } 1600func (c *InputService10ProtocolTest) InputService10TestCaseOperation1Request(input *InputService10TestShapeInputService10TestCaseOperation1Input) (req *request.Request, output *InputService10TestShapeInputService10TestCaseOperation1Output) { 1601 op := &request.Operation{ 1602 Name: opInputService10TestCaseOperation1, 1603 HTTPPath: "/", 1604 } 1605 1606 if input == nil { 1607 input = &InputService10TestShapeInputService10TestCaseOperation1Input{} 1608 } 1609 1610 output = &InputService10TestShapeInputService10TestCaseOperation1Output{} 1611 req = c.newRequest(op, input, output) 1612 req.Handlers.Unmarshal.Swap(ec2query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1613 return 1614} 1615 1616// InputService10TestCaseOperation1 API operation for . 1617// 1618// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1619// with awserr.Error's Code and Message methods to get detailed information about 1620// the error. 1621// 1622// See the AWS API reference guide for 's 1623// API operation InputService10TestCaseOperation1 for usage and error information. 1624func (c *InputService10ProtocolTest) InputService10TestCaseOperation1(input *InputService10TestShapeInputService10TestCaseOperation1Input) (*InputService10TestShapeInputService10TestCaseOperation1Output, error) { 1625 req, out := c.InputService10TestCaseOperation1Request(input) 1626 return out, req.Send() 1627} 1628 1629// InputService10TestCaseOperation1WithContext is the same as InputService10TestCaseOperation1 with the addition of 1630// the ability to pass a context and additional request options. 1631// 1632// See InputService10TestCaseOperation1 for details on how to use this API operation. 1633// 1634// The context must be non-nil and will be used for request cancellation. If 1635// the context is nil a panic will occur. In the future the SDK may create 1636// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1637// for more information on using Contexts. 1638func (c *InputService10ProtocolTest) InputService10TestCaseOperation1WithContext(ctx aws.Context, input *InputService10TestShapeInputService10TestCaseOperation1Input, opts ...request.Option) (*InputService10TestShapeInputService10TestCaseOperation1Output, error) { 1639 req, out := c.InputService10TestCaseOperation1Request(input) 1640 req.SetContext(ctx) 1641 req.ApplyOptions(opts...) 1642 return out, req.Send() 1643} 1644 1645const opInputService10TestCaseOperation2 = "OperationName" 1646 1647// InputService10TestCaseOperation2Request generates a "aws/request.Request" representing the 1648// client's request for the InputService10TestCaseOperation2 operation. The "output" return 1649// value will be populated with the request's response once the request completes 1650// successfully. 1651// 1652// Use "Send" method on the returned Request to send the API call to the service. 1653// the "output" return value is not valid until after Send returns without error. 1654// 1655// See InputService10TestCaseOperation2 for more information on using the InputService10TestCaseOperation2 1656// API call, and error handling. 1657// 1658// This method is useful when you want to inject custom logic or configuration 1659// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1660// 1661// 1662// // Example sending a request using the InputService10TestCaseOperation2Request method. 1663// req, resp := client.InputService10TestCaseOperation2Request(params) 1664// 1665// err := req.Send() 1666// if err == nil { // resp is now filled 1667// fmt.Println(resp) 1668// } 1669func (c *InputService10ProtocolTest) InputService10TestCaseOperation2Request(input *InputService10TestShapeInputService10TestCaseOperation2Input) (req *request.Request, output *InputService10TestShapeInputService10TestCaseOperation2Output) { 1670 op := &request.Operation{ 1671 Name: opInputService10TestCaseOperation2, 1672 HTTPPath: "/", 1673 } 1674 1675 if input == nil { 1676 input = &InputService10TestShapeInputService10TestCaseOperation2Input{} 1677 } 1678 1679 output = &InputService10TestShapeInputService10TestCaseOperation2Output{} 1680 req = c.newRequest(op, input, output) 1681 req.Handlers.Unmarshal.Swap(ec2query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1682 return 1683} 1684 1685// InputService10TestCaseOperation2 API operation for . 1686// 1687// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1688// with awserr.Error's Code and Message methods to get detailed information about 1689// the error. 1690// 1691// See the AWS API reference guide for 's 1692// API operation InputService10TestCaseOperation2 for usage and error information. 1693func (c *InputService10ProtocolTest) InputService10TestCaseOperation2(input *InputService10TestShapeInputService10TestCaseOperation2Input) (*InputService10TestShapeInputService10TestCaseOperation2Output, error) { 1694 req, out := c.InputService10TestCaseOperation2Request(input) 1695 return out, req.Send() 1696} 1697 1698// InputService10TestCaseOperation2WithContext is the same as InputService10TestCaseOperation2 with the addition of 1699// the ability to pass a context and additional request options. 1700// 1701// See InputService10TestCaseOperation2 for details on how to use this API operation. 1702// 1703// The context must be non-nil and will be used for request cancellation. If 1704// the context is nil a panic will occur. In the future the SDK may create 1705// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1706// for more information on using Contexts. 1707func (c *InputService10ProtocolTest) InputService10TestCaseOperation2WithContext(ctx aws.Context, input *InputService10TestShapeInputService10TestCaseOperation2Input, opts ...request.Option) (*InputService10TestShapeInputService10TestCaseOperation2Output, error) { 1708 req, out := c.InputService10TestCaseOperation2Request(input) 1709 req.SetContext(ctx) 1710 req.ApplyOptions(opts...) 1711 return out, req.Send() 1712} 1713 1714type InputService10TestShapeInputService10TestCaseOperation1Input struct { 1715 _ struct{} `type:"structure"` 1716 1717 FooEnum *string `type:"string" enum:"InputService10TestShapeEnumType"` 1718 1719 ListEnums []*string `type:"list"` 1720} 1721 1722// SetFooEnum sets the FooEnum field's value. 1723func (s *InputService10TestShapeInputService10TestCaseOperation1Input) SetFooEnum(v string) *InputService10TestShapeInputService10TestCaseOperation1Input { 1724 s.FooEnum = &v 1725 return s 1726} 1727 1728// SetListEnums sets the ListEnums field's value. 1729func (s *InputService10TestShapeInputService10TestCaseOperation1Input) SetListEnums(v []*string) *InputService10TestShapeInputService10TestCaseOperation1Input { 1730 s.ListEnums = v 1731 return s 1732} 1733 1734type InputService10TestShapeInputService10TestCaseOperation1Output struct { 1735 _ struct{} `type:"structure"` 1736} 1737 1738type InputService10TestShapeInputService10TestCaseOperation2Input struct { 1739 _ struct{} `type:"structure"` 1740 1741 FooEnum *string `type:"string" enum:"InputService10TestShapeEnumType"` 1742 1743 ListEnums []*string `type:"list"` 1744} 1745 1746// SetFooEnum sets the FooEnum field's value. 1747func (s *InputService10TestShapeInputService10TestCaseOperation2Input) SetFooEnum(v string) *InputService10TestShapeInputService10TestCaseOperation2Input { 1748 s.FooEnum = &v 1749 return s 1750} 1751 1752// SetListEnums sets the ListEnums field's value. 1753func (s *InputService10TestShapeInputService10TestCaseOperation2Input) SetListEnums(v []*string) *InputService10TestShapeInputService10TestCaseOperation2Input { 1754 s.ListEnums = v 1755 return s 1756} 1757 1758type InputService10TestShapeInputService10TestCaseOperation2Output struct { 1759 _ struct{} `type:"structure"` 1760} 1761 1762const ( 1763 // EnumTypeFoo is a InputService10TestShapeEnumType enum value 1764 EnumTypeFoo = "foo" 1765 1766 // EnumTypeBar is a InputService10TestShapeEnumType enum value 1767 EnumTypeBar = "bar" 1768) 1769 1770// InputService11ProtocolTest provides the API operation methods for making requests to 1771// . See this package's package overview docs 1772// for details on the service. 1773// 1774// InputService11ProtocolTest methods are safe to use concurrently. It is not safe to 1775// modify mutate any of the struct's properties though. 1776type InputService11ProtocolTest struct { 1777 *client.Client 1778} 1779 1780// New creates a new instance of the InputService11ProtocolTest client with a session. 1781// If additional configuration is needed for the client instance use the optional 1782// aws.Config parameter to add your extra config. 1783// 1784// Example: 1785// // Create a InputService11ProtocolTest client from just a session. 1786// svc := inputservice11protocoltest.New(mySession) 1787// 1788// // Create a InputService11ProtocolTest client with additional configuration 1789// svc := inputservice11protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1790func NewInputService11ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *InputService11ProtocolTest { 1791 c := p.ClientConfig("inputservice11protocoltest", cfgs...) 1792 return newInputService11ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1793} 1794 1795// newClient creates, initializes and returns a new service client instance. 1796func newInputService11ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *InputService11ProtocolTest { 1797 svc := &InputService11ProtocolTest{ 1798 Client: client.New( 1799 cfg, 1800 metadata.ClientInfo{ 1801 ServiceName: "InputService11ProtocolTest", 1802 ServiceID: "InputService11ProtocolTest", 1803 SigningName: signingName, 1804 SigningRegion: signingRegion, 1805 Endpoint: endpoint, 1806 APIVersion: "2014-01-01", 1807 }, 1808 handlers, 1809 ), 1810 } 1811 1812 // Handlers 1813 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1814 svc.Handlers.Build.PushBackNamed(ec2query.BuildHandler) 1815 svc.Handlers.Unmarshal.PushBackNamed(ec2query.UnmarshalHandler) 1816 svc.Handlers.UnmarshalMeta.PushBackNamed(ec2query.UnmarshalMetaHandler) 1817 svc.Handlers.UnmarshalError.PushBackNamed(ec2query.UnmarshalErrorHandler) 1818 1819 return svc 1820} 1821 1822// newRequest creates a new request for a InputService11ProtocolTest operation and runs any 1823// custom request initialization. 1824func (c *InputService11ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1825 req := c.NewRequest(op, params, data) 1826 1827 return req 1828} 1829 1830const opInputService11TestCaseOperation1 = "StaticOp" 1831 1832// InputService11TestCaseOperation1Request generates a "aws/request.Request" representing the 1833// client's request for the InputService11TestCaseOperation1 operation. The "output" return 1834// value will be populated with the request's response once the request completes 1835// successfully. 1836// 1837// Use "Send" method on the returned Request to send the API call to the service. 1838// the "output" return value is not valid until after Send returns without error. 1839// 1840// See InputService11TestCaseOperation1 for more information on using the InputService11TestCaseOperation1 1841// API call, and error handling. 1842// 1843// This method is useful when you want to inject custom logic or configuration 1844// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1845// 1846// 1847// // Example sending a request using the InputService11TestCaseOperation1Request method. 1848// req, resp := client.InputService11TestCaseOperation1Request(params) 1849// 1850// err := req.Send() 1851// if err == nil { // resp is now filled 1852// fmt.Println(resp) 1853// } 1854func (c *InputService11ProtocolTest) InputService11TestCaseOperation1Request(input *InputService11TestShapeInputService11TestCaseOperation1Input) (req *request.Request, output *InputService11TestShapeInputService11TestCaseOperation1Output) { 1855 op := &request.Operation{ 1856 Name: opInputService11TestCaseOperation1, 1857 HTTPPath: "/", 1858 } 1859 1860 if input == nil { 1861 input = &InputService11TestShapeInputService11TestCaseOperation1Input{} 1862 } 1863 1864 output = &InputService11TestShapeInputService11TestCaseOperation1Output{} 1865 req = c.newRequest(op, input, output) 1866 req.Handlers.Unmarshal.Swap(ec2query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1867 req.Handlers.Build.PushBackNamed(protocol.NewHostPrefixHandler("data-", nil)) 1868 req.Handlers.Build.PushBackNamed(protocol.ValidateEndpointHostHandler) 1869 return 1870} 1871 1872// InputService11TestCaseOperation1 API operation for . 1873// 1874// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1875// with awserr.Error's Code and Message methods to get detailed information about 1876// the error. 1877// 1878// See the AWS API reference guide for 's 1879// API operation InputService11TestCaseOperation1 for usage and error information. 1880func (c *InputService11ProtocolTest) InputService11TestCaseOperation1(input *InputService11TestShapeInputService11TestCaseOperation1Input) (*InputService11TestShapeInputService11TestCaseOperation1Output, error) { 1881 req, out := c.InputService11TestCaseOperation1Request(input) 1882 return out, req.Send() 1883} 1884 1885// InputService11TestCaseOperation1WithContext is the same as InputService11TestCaseOperation1 with the addition of 1886// the ability to pass a context and additional request options. 1887// 1888// See InputService11TestCaseOperation1 for details on how to use this API operation. 1889// 1890// The context must be non-nil and will be used for request cancellation. If 1891// the context is nil a panic will occur. In the future the SDK may create 1892// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1893// for more information on using Contexts. 1894func (c *InputService11ProtocolTest) InputService11TestCaseOperation1WithContext(ctx aws.Context, input *InputService11TestShapeInputService11TestCaseOperation1Input, opts ...request.Option) (*InputService11TestShapeInputService11TestCaseOperation1Output, error) { 1895 req, out := c.InputService11TestCaseOperation1Request(input) 1896 req.SetContext(ctx) 1897 req.ApplyOptions(opts...) 1898 return out, req.Send() 1899} 1900 1901const opInputService11TestCaseOperation2 = "MemberRefOp" 1902 1903// InputService11TestCaseOperation2Request generates a "aws/request.Request" representing the 1904// client's request for the InputService11TestCaseOperation2 operation. The "output" return 1905// value will be populated with the request's response once the request completes 1906// successfully. 1907// 1908// Use "Send" method on the returned Request to send the API call to the service. 1909// the "output" return value is not valid until after Send returns without error. 1910// 1911// See InputService11TestCaseOperation2 for more information on using the InputService11TestCaseOperation2 1912// API call, and error handling. 1913// 1914// This method is useful when you want to inject custom logic or configuration 1915// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1916// 1917// 1918// // Example sending a request using the InputService11TestCaseOperation2Request method. 1919// req, resp := client.InputService11TestCaseOperation2Request(params) 1920// 1921// err := req.Send() 1922// if err == nil { // resp is now filled 1923// fmt.Println(resp) 1924// } 1925func (c *InputService11ProtocolTest) InputService11TestCaseOperation2Request(input *InputService11TestShapeInputService11TestCaseOperation2Input) (req *request.Request, output *InputService11TestShapeInputService11TestCaseOperation2Output) { 1926 op := &request.Operation{ 1927 Name: opInputService11TestCaseOperation2, 1928 HTTPPath: "/", 1929 } 1930 1931 if input == nil { 1932 input = &InputService11TestShapeInputService11TestCaseOperation2Input{} 1933 } 1934 1935 output = &InputService11TestShapeInputService11TestCaseOperation2Output{} 1936 req = c.newRequest(op, input, output) 1937 req.Handlers.Unmarshal.Swap(ec2query.UnmarshalHandler.Name, protocol.UnmarshalDiscardBodyHandler) 1938 req.Handlers.Build.PushBackNamed(protocol.NewHostPrefixHandler("foo-{Name}.", input.hostLabels)) 1939 req.Handlers.Build.PushBackNamed(protocol.ValidateEndpointHostHandler) 1940 return 1941} 1942 1943// InputService11TestCaseOperation2 API operation for . 1944// 1945// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1946// with awserr.Error's Code and Message methods to get detailed information about 1947// the error. 1948// 1949// See the AWS API reference guide for 's 1950// API operation InputService11TestCaseOperation2 for usage and error information. 1951func (c *InputService11ProtocolTest) InputService11TestCaseOperation2(input *InputService11TestShapeInputService11TestCaseOperation2Input) (*InputService11TestShapeInputService11TestCaseOperation2Output, error) { 1952 req, out := c.InputService11TestCaseOperation2Request(input) 1953 return out, req.Send() 1954} 1955 1956// InputService11TestCaseOperation2WithContext is the same as InputService11TestCaseOperation2 with the addition of 1957// the ability to pass a context and additional request options. 1958// 1959// See InputService11TestCaseOperation2 for details on how to use this API operation. 1960// 1961// The context must be non-nil and will be used for request cancellation. If 1962// the context is nil a panic will occur. In the future the SDK may create 1963// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1964// for more information on using Contexts. 1965func (c *InputService11ProtocolTest) InputService11TestCaseOperation2WithContext(ctx aws.Context, input *InputService11TestShapeInputService11TestCaseOperation2Input, opts ...request.Option) (*InputService11TestShapeInputService11TestCaseOperation2Output, error) { 1966 req, out := c.InputService11TestCaseOperation2Request(input) 1967 req.SetContext(ctx) 1968 req.ApplyOptions(opts...) 1969 return out, req.Send() 1970} 1971 1972type InputService11TestShapeInputService11TestCaseOperation1Input struct { 1973 _ struct{} `type:"structure"` 1974 1975 Name *string `type:"string"` 1976} 1977 1978// SetName sets the Name field's value. 1979func (s *InputService11TestShapeInputService11TestCaseOperation1Input) SetName(v string) *InputService11TestShapeInputService11TestCaseOperation1Input { 1980 s.Name = &v 1981 return s 1982} 1983 1984type InputService11TestShapeInputService11TestCaseOperation1Output struct { 1985 _ struct{} `type:"structure"` 1986} 1987 1988type InputService11TestShapeInputService11TestCaseOperation2Input struct { 1989 _ struct{} `type:"structure"` 1990 1991 // Name is a required field 1992 Name *string `type:"string" required:"true"` 1993} 1994 1995// Validate inspects the fields of the type to determine if they are valid. 1996func (s *InputService11TestShapeInputService11TestCaseOperation2Input) Validate() error { 1997 invalidParams := request.ErrInvalidParams{Context: "InputService11TestShapeInputService11TestCaseOperation2Input"} 1998 if s.Name == nil { 1999 invalidParams.Add(request.NewErrParamRequired("Name")) 2000 } 2001 if s.Name != nil && len(*s.Name) < 1 { 2002 invalidParams.Add(request.NewErrParamMinLen("Name", 1)) 2003 } 2004 2005 if invalidParams.Len() > 0 { 2006 return invalidParams 2007 } 2008 return nil 2009} 2010 2011// SetName sets the Name field's value. 2012func (s *InputService11TestShapeInputService11TestCaseOperation2Input) SetName(v string) *InputService11TestShapeInputService11TestCaseOperation2Input { 2013 s.Name = &v 2014 return s 2015} 2016 2017func (s *InputService11TestShapeInputService11TestCaseOperation2Input) hostLabels() map[string]string { 2018 return map[string]string{ 2019 "Name": aws.StringValue(s.Name), 2020 } 2021} 2022 2023type InputService11TestShapeInputService11TestCaseOperation2Output struct { 2024 _ struct{} `type:"structure"` 2025} 2026 2027// 2028// Tests begin here 2029// 2030 2031func TestInputService1ProtocolTestScalarMembersCase1(t *testing.T) { 2032 svc := NewInputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2033 input := &InputService1TestShapeInputService1TestCaseOperation1Input{ 2034 Bar: aws.String("val2"), 2035 Foo: aws.String("val1"), 2036 } 2037 req, _ := svc.InputService1TestCaseOperation1Request(input) 2038 r := req.HTTPRequest 2039 2040 // build request 2041 req.Build() 2042 if req.Error != nil { 2043 t.Errorf("expect no error, got %v", req.Error) 2044 } 2045 2046 // assert body 2047 if r.Body == nil { 2048 t.Errorf("expect body not to be nil") 2049 } 2050 body, _ := ioutil.ReadAll(r.Body) 2051 awstesting.AssertQuery(t, `Action=OperationName&Bar=val2&Foo=val1&Version=2014-01-01`, util.Trim(string(body))) 2052 2053 // assert URL 2054 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2055 2056 // assert headers 2057 2058} 2059 2060func TestInputService2ProtocolTestStructureWithLocationNameAndQueryNameAppliedToMembersCase1(t *testing.T) { 2061 svc := NewInputService2ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2062 input := &InputService2TestShapeInputService2TestCaseOperation1Input{ 2063 Bar: aws.String("val2"), 2064 Foo: aws.String("val1"), 2065 Yuck: aws.String("val3"), 2066 } 2067 req, _ := svc.InputService2TestCaseOperation1Request(input) 2068 r := req.HTTPRequest 2069 2070 // build request 2071 req.Build() 2072 if req.Error != nil { 2073 t.Errorf("expect no error, got %v", req.Error) 2074 } 2075 2076 // assert body 2077 if r.Body == nil { 2078 t.Errorf("expect body not to be nil") 2079 } 2080 body, _ := ioutil.ReadAll(r.Body) 2081 awstesting.AssertQuery(t, `Action=OperationName&BarLocationName=val2&Foo=val1&Version=2014-01-01&yuckQueryName=val3`, util.Trim(string(body))) 2082 2083 // assert URL 2084 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2085 2086 // assert headers 2087 2088} 2089 2090func TestInputService3ProtocolTestNestedStructureMembersCase1(t *testing.T) { 2091 svc := NewInputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2092 input := &InputService3TestShapeInputService3TestCaseOperation1Input{ 2093 StructArg: &InputService3TestShapeStructType{ 2094 ScalarArg: aws.String("foo"), 2095 }, 2096 } 2097 req, _ := svc.InputService3TestCaseOperation1Request(input) 2098 r := req.HTTPRequest 2099 2100 // build request 2101 req.Build() 2102 if req.Error != nil { 2103 t.Errorf("expect no error, got %v", req.Error) 2104 } 2105 2106 // assert body 2107 if r.Body == nil { 2108 t.Errorf("expect body not to be nil") 2109 } 2110 body, _ := ioutil.ReadAll(r.Body) 2111 awstesting.AssertQuery(t, `Action=OperationName&Struct.Scalar=foo&Version=2014-01-01`, util.Trim(string(body))) 2112 2113 // assert URL 2114 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2115 2116 // assert headers 2117 2118} 2119 2120func TestInputService4ProtocolTestListTypesCase1(t *testing.T) { 2121 svc := NewInputService4ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2122 input := &InputService4TestShapeInputService4TestCaseOperation1Input{ 2123 ListBools: []*bool{ 2124 aws.Bool(true), 2125 aws.Bool(false), 2126 aws.Bool(false), 2127 }, 2128 ListFloats: []*float64{ 2129 aws.Float64(1.1), 2130 aws.Float64(2.718), 2131 aws.Float64(3.14), 2132 }, 2133 ListIntegers: []*int64{ 2134 aws.Int64(0), 2135 aws.Int64(1), 2136 aws.Int64(2), 2137 }, 2138 ListStrings: []*string{ 2139 aws.String("foo"), 2140 aws.String("bar"), 2141 aws.String("baz"), 2142 }, 2143 } 2144 req, _ := svc.InputService4TestCaseOperation1Request(input) 2145 r := req.HTTPRequest 2146 2147 // build request 2148 req.Build() 2149 if req.Error != nil { 2150 t.Errorf("expect no error, got %v", req.Error) 2151 } 2152 2153 // assert body 2154 if r.Body == nil { 2155 t.Errorf("expect body not to be nil") 2156 } 2157 body, _ := ioutil.ReadAll(r.Body) 2158 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))) 2159 2160 // assert URL 2161 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2162 2163 // assert headers 2164 2165} 2166 2167func TestInputService5ProtocolTestListWithLocationNameAppliedToMemberCase1(t *testing.T) { 2168 svc := NewInputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2169 input := &InputService5TestShapeInputService5TestCaseOperation1Input{ 2170 ListArg: []*string{ 2171 aws.String("a"), 2172 aws.String("b"), 2173 aws.String("c"), 2174 }, 2175 } 2176 req, _ := svc.InputService5TestCaseOperation1Request(input) 2177 r := req.HTTPRequest 2178 2179 // build request 2180 req.Build() 2181 if req.Error != nil { 2182 t.Errorf("expect no error, got %v", req.Error) 2183 } 2184 2185 // assert body 2186 if r.Body == nil { 2187 t.Errorf("expect body not to be nil") 2188 } 2189 body, _ := ioutil.ReadAll(r.Body) 2190 awstesting.AssertQuery(t, `Action=OperationName&ListMemberName.1=a&ListMemberName.2=b&ListMemberName.3=c&Version=2014-01-01`, util.Trim(string(body))) 2191 2192 // assert URL 2193 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2194 2195 // assert headers 2196 2197} 2198 2199func TestInputService6ProtocolTestListWithLocationNameAndQueryNameCase1(t *testing.T) { 2200 svc := NewInputService6ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2201 input := &InputService6TestShapeInputService6TestCaseOperation1Input{ 2202 ListArg: []*string{ 2203 aws.String("a"), 2204 aws.String("b"), 2205 aws.String("c"), 2206 }, 2207 } 2208 req, _ := svc.InputService6TestCaseOperation1Request(input) 2209 r := req.HTTPRequest 2210 2211 // build request 2212 req.Build() 2213 if req.Error != nil { 2214 t.Errorf("expect no error, got %v", req.Error) 2215 } 2216 2217 // assert body 2218 if r.Body == nil { 2219 t.Errorf("expect body not to be nil") 2220 } 2221 body, _ := ioutil.ReadAll(r.Body) 2222 awstesting.AssertQuery(t, `Action=OperationName&ListQueryName.1=a&ListQueryName.2=b&ListQueryName.3=c&Version=2014-01-01`, util.Trim(string(body))) 2223 2224 // assert URL 2225 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2226 2227 // assert headers 2228 2229} 2230 2231func TestInputService7ProtocolTestBase64EncodedBlobsCase1(t *testing.T) { 2232 svc := NewInputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2233 input := &InputService7TestShapeInputService7TestCaseOperation1Input{ 2234 BlobArg: []byte("foo"), 2235 } 2236 req, _ := svc.InputService7TestCaseOperation1Request(input) 2237 r := req.HTTPRequest 2238 2239 // build request 2240 req.Build() 2241 if req.Error != nil { 2242 t.Errorf("expect no error, got %v", req.Error) 2243 } 2244 2245 // assert body 2246 if r.Body == nil { 2247 t.Errorf("expect body not to be nil") 2248 } 2249 body, _ := ioutil.ReadAll(r.Body) 2250 awstesting.AssertQuery(t, `Action=OperationName&BlobArg=Zm9v&Version=2014-01-01`, util.Trim(string(body))) 2251 2252 // assert URL 2253 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2254 2255 // assert headers 2256 2257} 2258 2259func TestInputService8ProtocolTestTimestampValuesCase1(t *testing.T) { 2260 svc := NewInputService8ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2261 input := &InputService8TestShapeInputService8TestCaseOperation1Input{ 2262 TimeArg: aws.Time(time.Unix(1422172800, 0)), 2263 TimeCustom: aws.Time(time.Unix(1422172800, 0)), 2264 TimeFormat: aws.Time(time.Unix(1422172800, 0)), 2265 } 2266 req, _ := svc.InputService8TestCaseOperation1Request(input) 2267 r := req.HTTPRequest 2268 2269 // build request 2270 req.Build() 2271 if req.Error != nil { 2272 t.Errorf("expect no error, got %v", req.Error) 2273 } 2274 2275 // assert body 2276 if r.Body == nil { 2277 t.Errorf("expect body not to be nil") 2278 } 2279 body, _ := ioutil.ReadAll(r.Body) 2280 awstesting.AssertQuery(t, `Action=OperationName&TimeArg=2015-01-25T08%3A00%3A00Z&TimeCustom=1422172800&TimeFormat=1422172800&Version=2014-01-01`, util.Trim(string(body))) 2281 2282 // assert URL 2283 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2284 2285 // assert headers 2286 2287} 2288 2289func TestInputService9ProtocolTestIdempotencyTokenAutoFillCase1(t *testing.T) { 2290 svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2291 input := &InputService9TestShapeInputService9TestCaseOperation1Input{ 2292 Token: aws.String("abc123"), 2293 } 2294 req, _ := svc.InputService9TestCaseOperation1Request(input) 2295 r := req.HTTPRequest 2296 2297 // build request 2298 req.Build() 2299 if req.Error != nil { 2300 t.Errorf("expect no error, got %v", req.Error) 2301 } 2302 2303 // assert body 2304 if r.Body == nil { 2305 t.Errorf("expect body not to be nil") 2306 } 2307 body, _ := ioutil.ReadAll(r.Body) 2308 awstesting.AssertQuery(t, `Action=OperationName&Token=abc123&Version=2014-01-01`, util.Trim(string(body))) 2309 2310 // assert URL 2311 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2312 2313 // assert headers 2314 2315} 2316 2317func TestInputService9ProtocolTestIdempotencyTokenAutoFillCase2(t *testing.T) { 2318 svc := NewInputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2319 input := &InputService9TestShapeInputService9TestCaseOperation2Input{} 2320 req, _ := svc.InputService9TestCaseOperation2Request(input) 2321 r := req.HTTPRequest 2322 2323 // build request 2324 req.Build() 2325 if req.Error != nil { 2326 t.Errorf("expect no error, got %v", req.Error) 2327 } 2328 2329 // assert body 2330 if r.Body == nil { 2331 t.Errorf("expect body not to be nil") 2332 } 2333 body, _ := ioutil.ReadAll(r.Body) 2334 awstesting.AssertQuery(t, `Action=OperationName&Token=00000000-0000-4000-8000-000000000000&Version=2014-01-01`, util.Trim(string(body))) 2335 2336 // assert URL 2337 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2338 2339 // assert headers 2340 2341} 2342 2343func TestInputService10ProtocolTestEnumCase1(t *testing.T) { 2344 svc := NewInputService10ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2345 input := &InputService10TestShapeInputService10TestCaseOperation1Input{ 2346 ListEnums: []*string{ 2347 aws.String("foo"), 2348 aws.String(""), 2349 aws.String("bar"), 2350 }, 2351 } 2352 req, _ := svc.InputService10TestCaseOperation1Request(input) 2353 r := req.HTTPRequest 2354 2355 // build request 2356 req.Build() 2357 if req.Error != nil { 2358 t.Errorf("expect no error, got %v", req.Error) 2359 } 2360 2361 // assert body 2362 if r.Body == nil { 2363 t.Errorf("expect body not to be nil") 2364 } 2365 body, _ := ioutil.ReadAll(r.Body) 2366 awstesting.AssertQuery(t, `Action=OperationName&ListEnums.1=foo&ListEnums.2=&ListEnums.3=bar&Version=2014-01-01`, util.Trim(string(body))) 2367 2368 // assert URL 2369 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2370 2371 // assert headers 2372 2373} 2374 2375func TestInputService10ProtocolTestEnumCase2(t *testing.T) { 2376 svc := NewInputService10ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2377 input := &InputService10TestShapeInputService10TestCaseOperation2Input{} 2378 req, _ := svc.InputService10TestCaseOperation2Request(input) 2379 r := req.HTTPRequest 2380 2381 // build request 2382 req.Build() 2383 if req.Error != nil { 2384 t.Errorf("expect no error, got %v", req.Error) 2385 } 2386 2387 // assert body 2388 if r.Body == nil { 2389 t.Errorf("expect body not to be nil") 2390 } 2391 body, _ := ioutil.ReadAll(r.Body) 2392 awstesting.AssertQuery(t, `Action=OperationName&Version=2014-01-01`, util.Trim(string(body))) 2393 2394 // assert URL 2395 awstesting.AssertURL(t, "https://test/", r.URL.String()) 2396 2397 // assert headers 2398 2399} 2400 2401func TestInputService11ProtocolTestEndpointHostTraitCase1(t *testing.T) { 2402 svc := NewInputService11ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://service.region.amazonaws.com")}) 2403 input := &InputService11TestShapeInputService11TestCaseOperation1Input{ 2404 Name: aws.String("myname"), 2405 } 2406 req, _ := svc.InputService11TestCaseOperation1Request(input) 2407 r := req.HTTPRequest 2408 2409 // build request 2410 req.Build() 2411 if req.Error != nil { 2412 t.Errorf("expect no error, got %v", req.Error) 2413 } 2414 2415 // assert body 2416 if r.Body == nil { 2417 t.Errorf("expect body not to be nil") 2418 } 2419 body, _ := ioutil.ReadAll(r.Body) 2420 awstesting.AssertQuery(t, `Action=StaticOp&Name=myname&Version=2014-01-01`, util.Trim(string(body))) 2421 2422 // assert URL 2423 awstesting.AssertURL(t, "https://data-service.region.amazonaws.com/", r.URL.String()) 2424 2425 // assert headers 2426 2427} 2428 2429func TestInputService11ProtocolTestEndpointHostTraitCase2(t *testing.T) { 2430 svc := NewInputService11ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://service.region.amazonaws.com")}) 2431 input := &InputService11TestShapeInputService11TestCaseOperation2Input{ 2432 Name: aws.String("myname"), 2433 } 2434 req, _ := svc.InputService11TestCaseOperation2Request(input) 2435 r := req.HTTPRequest 2436 2437 // build request 2438 req.Build() 2439 if req.Error != nil { 2440 t.Errorf("expect no error, got %v", req.Error) 2441 } 2442 2443 // assert body 2444 if r.Body == nil { 2445 t.Errorf("expect body not to be nil") 2446 } 2447 body, _ := ioutil.ReadAll(r.Body) 2448 awstesting.AssertQuery(t, `Action=MemberRefOp&Name=myname&Version=2014-01-01`, util.Trim(string(body))) 2449 2450 // assert URL 2451 awstesting.AssertURL(t, "https://foo-myname.service.region.amazonaws.com/", r.URL.String()) 2452 2453 // assert headers 2454 2455} 2456