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