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