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