1package restxml_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/restxml" 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(restxml.BuildHandler) 92 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 93 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 94 svc.Handlers.UnmarshalError.PushBackNamed(restxml.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 *OutputService1TestShapeOutputService1TestCaseOperation3Output) { 132 op := &request.Operation{ 133 Name: opOutputService1TestCaseOperation1, 134 HTTPPath: "/", 135 } 136 137 if input == nil { 138 input = &OutputService1TestShapeOutputService1TestCaseOperation1Input{} 139 } 140 141 output = &OutputService1TestShapeOutputService1TestCaseOperation3Output{} 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) (*OutputService1TestShapeOutputService1TestCaseOperation3Output, 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) (*OutputService1TestShapeOutputService1TestCaseOperation3Output, error) { 169 req, out := c.OutputService1TestCaseOperation1Request(input) 170 req.SetContext(ctx) 171 req.ApplyOptions(opts...) 172 return out, req.Send() 173} 174 175const opOutputService1TestCaseOperation2 = "OperationName" 176 177// OutputService1TestCaseOperation2Request generates a "aws/request.Request" representing the 178// client's request for the OutputService1TestCaseOperation2 operation. The "output" return 179// value will be populated with the request's response once the request completes 180// successfuly. 181// 182// Use "Send" method on the returned Request to send the API call to the service. 183// the "output" return value is not valid until after Send returns without error. 184// 185// See OutputService1TestCaseOperation2 for more information on using the OutputService1TestCaseOperation2 186// API call, and error handling. 187// 188// This method is useful when you want to inject custom logic or configuration 189// into the SDK's request lifecycle. Such as custom headers, or retry logic. 190// 191// 192// // Example sending a request using the OutputService1TestCaseOperation2Request method. 193// req, resp := client.OutputService1TestCaseOperation2Request(params) 194// 195// err := req.Send() 196// if err == nil { // resp is now filled 197// fmt.Println(resp) 198// } 199func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2Request(input *OutputService1TestShapeOutputService1TestCaseOperation2Input) (req *request.Request, output *OutputService1TestShapeOutputService1TestCaseOperation3Output) { 200 op := &request.Operation{ 201 Name: opOutputService1TestCaseOperation2, 202 HTTPPath: "/", 203 } 204 205 if input == nil { 206 input = &OutputService1TestShapeOutputService1TestCaseOperation2Input{} 207 } 208 209 output = &OutputService1TestShapeOutputService1TestCaseOperation3Output{} 210 req = c.newRequest(op, input, output) 211 return 212} 213 214// OutputService1TestCaseOperation2 API operation for . 215// 216// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 217// with awserr.Error's Code and Message methods to get detailed information about 218// the error. 219// 220// See the AWS API reference guide for 's 221// API operation OutputService1TestCaseOperation2 for usage and error information. 222func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2(input *OutputService1TestShapeOutputService1TestCaseOperation2Input) (*OutputService1TestShapeOutputService1TestCaseOperation3Output, error) { 223 req, out := c.OutputService1TestCaseOperation2Request(input) 224 return out, req.Send() 225} 226 227// OutputService1TestCaseOperation2WithContext is the same as OutputService1TestCaseOperation2 with the addition of 228// the ability to pass a context and additional request options. 229// 230// See OutputService1TestCaseOperation2 for details on how to use this API operation. 231// 232// The context must be non-nil and will be used for request cancellation. If 233// the context is nil a panic will occur. In the future the SDK may create 234// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 235// for more information on using Contexts. 236func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation2WithContext(ctx aws.Context, input *OutputService1TestShapeOutputService1TestCaseOperation2Input, opts ...request.Option) (*OutputService1TestShapeOutputService1TestCaseOperation3Output, error) { 237 req, out := c.OutputService1TestCaseOperation2Request(input) 238 req.SetContext(ctx) 239 req.ApplyOptions(opts...) 240 return out, req.Send() 241} 242 243const opOutputService1TestCaseOperation3 = "OperationName" 244 245// OutputService1TestCaseOperation3Request generates a "aws/request.Request" representing the 246// client's request for the OutputService1TestCaseOperation3 operation. The "output" return 247// value will be populated with the request's response once the request completes 248// successfuly. 249// 250// Use "Send" method on the returned Request to send the API call to the service. 251// the "output" return value is not valid until after Send returns without error. 252// 253// See OutputService1TestCaseOperation3 for more information on using the OutputService1TestCaseOperation3 254// API call, and error handling. 255// 256// This method is useful when you want to inject custom logic or configuration 257// into the SDK's request lifecycle. Such as custom headers, or retry logic. 258// 259// 260// // Example sending a request using the OutputService1TestCaseOperation3Request method. 261// req, resp := client.OutputService1TestCaseOperation3Request(params) 262// 263// err := req.Send() 264// if err == nil { // resp is now filled 265// fmt.Println(resp) 266// } 267func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation3Request(input *OutputService1TestShapeOutputService1TestCaseOperation3Input) (req *request.Request, output *OutputService1TestShapeOutputService1TestCaseOperation3Output) { 268 op := &request.Operation{ 269 Name: opOutputService1TestCaseOperation3, 270 HTTPPath: "/", 271 } 272 273 if input == nil { 274 input = &OutputService1TestShapeOutputService1TestCaseOperation3Input{} 275 } 276 277 output = &OutputService1TestShapeOutputService1TestCaseOperation3Output{} 278 req = c.newRequest(op, input, output) 279 return 280} 281 282// OutputService1TestCaseOperation3 API operation for . 283// 284// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 285// with awserr.Error's Code and Message methods to get detailed information about 286// the error. 287// 288// See the AWS API reference guide for 's 289// API operation OutputService1TestCaseOperation3 for usage and error information. 290func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation3(input *OutputService1TestShapeOutputService1TestCaseOperation3Input) (*OutputService1TestShapeOutputService1TestCaseOperation3Output, error) { 291 req, out := c.OutputService1TestCaseOperation3Request(input) 292 return out, req.Send() 293} 294 295// OutputService1TestCaseOperation3WithContext is the same as OutputService1TestCaseOperation3 with the addition of 296// the ability to pass a context and additional request options. 297// 298// See OutputService1TestCaseOperation3 for details on how to use this API operation. 299// 300// The context must be non-nil and will be used for request cancellation. If 301// the context is nil a panic will occur. In the future the SDK may create 302// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 303// for more information on using Contexts. 304func (c *OutputService1ProtocolTest) OutputService1TestCaseOperation3WithContext(ctx aws.Context, input *OutputService1TestShapeOutputService1TestCaseOperation3Input, opts ...request.Option) (*OutputService1TestShapeOutputService1TestCaseOperation3Output, error) { 305 req, out := c.OutputService1TestCaseOperation3Request(input) 306 req.SetContext(ctx) 307 req.ApplyOptions(opts...) 308 return out, req.Send() 309} 310 311type OutputService1TestShapeOutputService1TestCaseOperation1Input struct { 312 _ struct{} `type:"structure"` 313} 314 315type OutputService1TestShapeOutputService1TestCaseOperation2Input struct { 316 _ struct{} `type:"structure"` 317} 318 319type OutputService1TestShapeOutputService1TestCaseOperation3Input struct { 320 _ struct{} `type:"structure"` 321} 322 323type OutputService1TestShapeOutputService1TestCaseOperation3Output struct { 324 _ struct{} `type:"structure"` 325 326 Blobs [][]byte `type:"list"` 327 328 Char *string `type:"character"` 329 330 Double *float64 `type:"double"` 331 332 FalseBool *bool `type:"boolean"` 333 334 Float *float64 `type:"float"` 335 336 ImaHeader *string `location:"header" type:"string"` 337 338 ImaHeaderLocation *string `location:"header" locationName:"X-Foo" type:"string"` 339 340 Long *int64 `type:"long"` 341 342 Num *int64 `locationName:"FooNum" type:"integer"` 343 344 Str *string `type:"string"` 345 346 Timestamp *time.Time `type:"timestamp" timestampFormat:"iso8601"` 347 348 Timestamps []*time.Time `type:"list"` 349 350 TrueBool *bool `type:"boolean"` 351} 352 353// SetBlobs sets the Blobs field's value. 354func (s *OutputService1TestShapeOutputService1TestCaseOperation3Output) SetBlobs(v [][]byte) *OutputService1TestShapeOutputService1TestCaseOperation3Output { 355 s.Blobs = v 356 return s 357} 358 359// SetChar sets the Char field's value. 360func (s *OutputService1TestShapeOutputService1TestCaseOperation3Output) SetChar(v string) *OutputService1TestShapeOutputService1TestCaseOperation3Output { 361 s.Char = &v 362 return s 363} 364 365// SetDouble sets the Double field's value. 366func (s *OutputService1TestShapeOutputService1TestCaseOperation3Output) SetDouble(v float64) *OutputService1TestShapeOutputService1TestCaseOperation3Output { 367 s.Double = &v 368 return s 369} 370 371// SetFalseBool sets the FalseBool field's value. 372func (s *OutputService1TestShapeOutputService1TestCaseOperation3Output) SetFalseBool(v bool) *OutputService1TestShapeOutputService1TestCaseOperation3Output { 373 s.FalseBool = &v 374 return s 375} 376 377// SetFloat sets the Float field's value. 378func (s *OutputService1TestShapeOutputService1TestCaseOperation3Output) SetFloat(v float64) *OutputService1TestShapeOutputService1TestCaseOperation3Output { 379 s.Float = &v 380 return s 381} 382 383// SetImaHeader sets the ImaHeader field's value. 384func (s *OutputService1TestShapeOutputService1TestCaseOperation3Output) SetImaHeader(v string) *OutputService1TestShapeOutputService1TestCaseOperation3Output { 385 s.ImaHeader = &v 386 return s 387} 388 389// SetImaHeaderLocation sets the ImaHeaderLocation field's value. 390func (s *OutputService1TestShapeOutputService1TestCaseOperation3Output) SetImaHeaderLocation(v string) *OutputService1TestShapeOutputService1TestCaseOperation3Output { 391 s.ImaHeaderLocation = &v 392 return s 393} 394 395// SetLong sets the Long field's value. 396func (s *OutputService1TestShapeOutputService1TestCaseOperation3Output) SetLong(v int64) *OutputService1TestShapeOutputService1TestCaseOperation3Output { 397 s.Long = &v 398 return s 399} 400 401// SetNum sets the Num field's value. 402func (s *OutputService1TestShapeOutputService1TestCaseOperation3Output) SetNum(v int64) *OutputService1TestShapeOutputService1TestCaseOperation3Output { 403 s.Num = &v 404 return s 405} 406 407// SetStr sets the Str field's value. 408func (s *OutputService1TestShapeOutputService1TestCaseOperation3Output) SetStr(v string) *OutputService1TestShapeOutputService1TestCaseOperation3Output { 409 s.Str = &v 410 return s 411} 412 413// SetTimestamp sets the Timestamp field's value. 414func (s *OutputService1TestShapeOutputService1TestCaseOperation3Output) SetTimestamp(v time.Time) *OutputService1TestShapeOutputService1TestCaseOperation3Output { 415 s.Timestamp = &v 416 return s 417} 418 419// SetTimestamps sets the Timestamps field's value. 420func (s *OutputService1TestShapeOutputService1TestCaseOperation3Output) SetTimestamps(v []*time.Time) *OutputService1TestShapeOutputService1TestCaseOperation3Output { 421 s.Timestamps = v 422 return s 423} 424 425// SetTrueBool sets the TrueBool field's value. 426func (s *OutputService1TestShapeOutputService1TestCaseOperation3Output) SetTrueBool(v bool) *OutputService1TestShapeOutputService1TestCaseOperation3Output { 427 s.TrueBool = &v 428 return s 429} 430 431// OutputService2ProtocolTest provides the API operation methods for making requests to 432// . See this package's package overview docs 433// for details on the service. 434// 435// OutputService2ProtocolTest methods are safe to use concurrently. It is not safe to 436// modify mutate any of the struct's properties though. 437type OutputService2ProtocolTest struct { 438 *client.Client 439} 440 441// New creates a new instance of the OutputService2ProtocolTest client with a session. 442// If additional configuration is needed for the client instance use the optional 443// aws.Config parameter to add your extra config. 444// 445// Example: 446// // Create a OutputService2ProtocolTest client from just a session. 447// svc := outputservice2protocoltest.New(mySession) 448// 449// // Create a OutputService2ProtocolTest client with additional configuration 450// svc := outputservice2protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 451func NewOutputService2ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *OutputService2ProtocolTest { 452 c := p.ClientConfig("outputservice2protocoltest", cfgs...) 453 return newOutputService2ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 454} 455 456// newClient creates, initializes and returns a new service client instance. 457func newOutputService2ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *OutputService2ProtocolTest { 458 svc := &OutputService2ProtocolTest{ 459 Client: client.New( 460 cfg, 461 metadata.ClientInfo{ 462 ServiceName: "OutputService2ProtocolTest", 463 ServiceID: "OutputService2ProtocolTest", 464 SigningName: signingName, 465 SigningRegion: signingRegion, 466 Endpoint: endpoint, 467 APIVersion: "", 468 }, 469 handlers, 470 ), 471 } 472 473 // Handlers 474 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 475 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 476 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 477 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 478 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 479 480 return svc 481} 482 483// newRequest creates a new request for a OutputService2ProtocolTest operation and runs any 484// custom request initialization. 485func (c *OutputService2ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 486 req := c.NewRequest(op, params, data) 487 488 return req 489} 490 491const opOutputService2TestCaseOperation1 = "OperationName" 492 493// OutputService2TestCaseOperation1Request generates a "aws/request.Request" representing the 494// client's request for the OutputService2TestCaseOperation1 operation. The "output" return 495// value will be populated with the request's response once the request completes 496// successfuly. 497// 498// Use "Send" method on the returned Request to send the API call to the service. 499// the "output" return value is not valid until after Send returns without error. 500// 501// See OutputService2TestCaseOperation1 for more information on using the OutputService2TestCaseOperation1 502// API call, and error handling. 503// 504// This method is useful when you want to inject custom logic or configuration 505// into the SDK's request lifecycle. Such as custom headers, or retry logic. 506// 507// 508// // Example sending a request using the OutputService2TestCaseOperation1Request method. 509// req, resp := client.OutputService2TestCaseOperation1Request(params) 510// 511// err := req.Send() 512// if err == nil { // resp is now filled 513// fmt.Println(resp) 514// } 515func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1Request(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (req *request.Request, output *OutputService2TestShapeOutputService2TestCaseOperation1Output) { 516 op := &request.Operation{ 517 Name: opOutputService2TestCaseOperation1, 518 HTTPPath: "/", 519 } 520 521 if input == nil { 522 input = &OutputService2TestShapeOutputService2TestCaseOperation1Input{} 523 } 524 525 output = &OutputService2TestShapeOutputService2TestCaseOperation1Output{} 526 req = c.newRequest(op, input, output) 527 return 528} 529 530// OutputService2TestCaseOperation1 API operation for . 531// 532// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 533// with awserr.Error's Code and Message methods to get detailed information about 534// the error. 535// 536// See the AWS API reference guide for 's 537// API operation OutputService2TestCaseOperation1 for usage and error information. 538func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1(input *OutputService2TestShapeOutputService2TestCaseOperation1Input) (*OutputService2TestShapeOutputService2TestCaseOperation1Output, error) { 539 req, out := c.OutputService2TestCaseOperation1Request(input) 540 return out, req.Send() 541} 542 543// OutputService2TestCaseOperation1WithContext is the same as OutputService2TestCaseOperation1 with the addition of 544// the ability to pass a context and additional request options. 545// 546// See OutputService2TestCaseOperation1 for details on how to use this API operation. 547// 548// The context must be non-nil and will be used for request cancellation. If 549// the context is nil a panic will occur. In the future the SDK may create 550// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 551// for more information on using Contexts. 552func (c *OutputService2ProtocolTest) OutputService2TestCaseOperation1WithContext(ctx aws.Context, input *OutputService2TestShapeOutputService2TestCaseOperation1Input, opts ...request.Option) (*OutputService2TestShapeOutputService2TestCaseOperation1Output, error) { 553 req, out := c.OutputService2TestCaseOperation1Request(input) 554 req.SetContext(ctx) 555 req.ApplyOptions(opts...) 556 return out, req.Send() 557} 558 559type OutputService2TestShapeOutputService2TestCaseOperation1Input struct { 560 _ struct{} `type:"structure"` 561} 562 563type OutputService2TestShapeOutputService2TestCaseOperation1Output struct { 564 _ struct{} `type:"structure"` 565 566 // Blob is automatically base64 encoded/decoded by the SDK. 567 Blob []byte `type:"blob"` 568} 569 570// SetBlob sets the Blob field's value. 571func (s *OutputService2TestShapeOutputService2TestCaseOperation1Output) SetBlob(v []byte) *OutputService2TestShapeOutputService2TestCaseOperation1Output { 572 s.Blob = v 573 return s 574} 575 576// OutputService3ProtocolTest provides the API operation methods for making requests to 577// . See this package's package overview docs 578// for details on the service. 579// 580// OutputService3ProtocolTest methods are safe to use concurrently. It is not safe to 581// modify mutate any of the struct's properties though. 582type OutputService3ProtocolTest struct { 583 *client.Client 584} 585 586// New creates a new instance of the OutputService3ProtocolTest client with a session. 587// If additional configuration is needed for the client instance use the optional 588// aws.Config parameter to add your extra config. 589// 590// Example: 591// // Create a OutputService3ProtocolTest client from just a session. 592// svc := outputservice3protocoltest.New(mySession) 593// 594// // Create a OutputService3ProtocolTest client with additional configuration 595// svc := outputservice3protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 596func NewOutputService3ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *OutputService3ProtocolTest { 597 c := p.ClientConfig("outputservice3protocoltest", cfgs...) 598 return newOutputService3ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 599} 600 601// newClient creates, initializes and returns a new service client instance. 602func newOutputService3ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *OutputService3ProtocolTest { 603 svc := &OutputService3ProtocolTest{ 604 Client: client.New( 605 cfg, 606 metadata.ClientInfo{ 607 ServiceName: "OutputService3ProtocolTest", 608 ServiceID: "OutputService3ProtocolTest", 609 SigningName: signingName, 610 SigningRegion: signingRegion, 611 Endpoint: endpoint, 612 APIVersion: "", 613 }, 614 handlers, 615 ), 616 } 617 618 // Handlers 619 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 620 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 621 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 622 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 623 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 624 625 return svc 626} 627 628// newRequest creates a new request for a OutputService3ProtocolTest operation and runs any 629// custom request initialization. 630func (c *OutputService3ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 631 req := c.NewRequest(op, params, data) 632 633 return req 634} 635 636const opOutputService3TestCaseOperation1 = "OperationName" 637 638// OutputService3TestCaseOperation1Request generates a "aws/request.Request" representing the 639// client's request for the OutputService3TestCaseOperation1 operation. The "output" return 640// value will be populated with the request's response once the request completes 641// successfuly. 642// 643// Use "Send" method on the returned Request to send the API call to the service. 644// the "output" return value is not valid until after Send returns without error. 645// 646// See OutputService3TestCaseOperation1 for more information on using the OutputService3TestCaseOperation1 647// API call, and error handling. 648// 649// This method is useful when you want to inject custom logic or configuration 650// into the SDK's request lifecycle. Such as custom headers, or retry logic. 651// 652// 653// // Example sending a request using the OutputService3TestCaseOperation1Request method. 654// req, resp := client.OutputService3TestCaseOperation1Request(params) 655// 656// err := req.Send() 657// if err == nil { // resp is now filled 658// fmt.Println(resp) 659// } 660func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1Request(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (req *request.Request, output *OutputService3TestShapeOutputService3TestCaseOperation1Output) { 661 op := &request.Operation{ 662 Name: opOutputService3TestCaseOperation1, 663 HTTPPath: "/", 664 } 665 666 if input == nil { 667 input = &OutputService3TestShapeOutputService3TestCaseOperation1Input{} 668 } 669 670 output = &OutputService3TestShapeOutputService3TestCaseOperation1Output{} 671 req = c.newRequest(op, input, output) 672 return 673} 674 675// OutputService3TestCaseOperation1 API operation for . 676// 677// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 678// with awserr.Error's Code and Message methods to get detailed information about 679// the error. 680// 681// See the AWS API reference guide for 's 682// API operation OutputService3TestCaseOperation1 for usage and error information. 683func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1(input *OutputService3TestShapeOutputService3TestCaseOperation1Input) (*OutputService3TestShapeOutputService3TestCaseOperation1Output, error) { 684 req, out := c.OutputService3TestCaseOperation1Request(input) 685 return out, req.Send() 686} 687 688// OutputService3TestCaseOperation1WithContext is the same as OutputService3TestCaseOperation1 with the addition of 689// the ability to pass a context and additional request options. 690// 691// See OutputService3TestCaseOperation1 for details on how to use this API operation. 692// 693// The context must be non-nil and will be used for request cancellation. If 694// the context is nil a panic will occur. In the future the SDK may create 695// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 696// for more information on using Contexts. 697func (c *OutputService3ProtocolTest) OutputService3TestCaseOperation1WithContext(ctx aws.Context, input *OutputService3TestShapeOutputService3TestCaseOperation1Input, opts ...request.Option) (*OutputService3TestShapeOutputService3TestCaseOperation1Output, error) { 698 req, out := c.OutputService3TestCaseOperation1Request(input) 699 req.SetContext(ctx) 700 req.ApplyOptions(opts...) 701 return out, req.Send() 702} 703 704type OutputService3TestShapeOutputService3TestCaseOperation1Input struct { 705 _ struct{} `type:"structure"` 706} 707 708type OutputService3TestShapeOutputService3TestCaseOperation1Output struct { 709 _ struct{} `type:"structure"` 710 711 ListMember []*string `type:"list"` 712} 713 714// SetListMember sets the ListMember field's value. 715func (s *OutputService3TestShapeOutputService3TestCaseOperation1Output) SetListMember(v []*string) *OutputService3TestShapeOutputService3TestCaseOperation1Output { 716 s.ListMember = v 717 return s 718} 719 720// OutputService4ProtocolTest provides the API operation methods for making requests to 721// . See this package's package overview docs 722// for details on the service. 723// 724// OutputService4ProtocolTest methods are safe to use concurrently. It is not safe to 725// modify mutate any of the struct's properties though. 726type OutputService4ProtocolTest struct { 727 *client.Client 728} 729 730// New creates a new instance of the OutputService4ProtocolTest client with a session. 731// If additional configuration is needed for the client instance use the optional 732// aws.Config parameter to add your extra config. 733// 734// Example: 735// // Create a OutputService4ProtocolTest client from just a session. 736// svc := outputservice4protocoltest.New(mySession) 737// 738// // Create a OutputService4ProtocolTest client with additional configuration 739// svc := outputservice4protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 740func NewOutputService4ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *OutputService4ProtocolTest { 741 c := p.ClientConfig("outputservice4protocoltest", cfgs...) 742 return newOutputService4ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 743} 744 745// newClient creates, initializes and returns a new service client instance. 746func newOutputService4ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *OutputService4ProtocolTest { 747 svc := &OutputService4ProtocolTest{ 748 Client: client.New( 749 cfg, 750 metadata.ClientInfo{ 751 ServiceName: "OutputService4ProtocolTest", 752 ServiceID: "OutputService4ProtocolTest", 753 SigningName: signingName, 754 SigningRegion: signingRegion, 755 Endpoint: endpoint, 756 APIVersion: "", 757 }, 758 handlers, 759 ), 760 } 761 762 // Handlers 763 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 764 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 765 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 766 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 767 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 768 769 return svc 770} 771 772// newRequest creates a new request for a OutputService4ProtocolTest operation and runs any 773// custom request initialization. 774func (c *OutputService4ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 775 req := c.NewRequest(op, params, data) 776 777 return req 778} 779 780const opOutputService4TestCaseOperation1 = "OperationName" 781 782// OutputService4TestCaseOperation1Request generates a "aws/request.Request" representing the 783// client's request for the OutputService4TestCaseOperation1 operation. The "output" return 784// value will be populated with the request's response once the request completes 785// successfuly. 786// 787// Use "Send" method on the returned Request to send the API call to the service. 788// the "output" return value is not valid until after Send returns without error. 789// 790// See OutputService4TestCaseOperation1 for more information on using the OutputService4TestCaseOperation1 791// API call, and error handling. 792// 793// This method is useful when you want to inject custom logic or configuration 794// into the SDK's request lifecycle. Such as custom headers, or retry logic. 795// 796// 797// // Example sending a request using the OutputService4TestCaseOperation1Request method. 798// req, resp := client.OutputService4TestCaseOperation1Request(params) 799// 800// err := req.Send() 801// if err == nil { // resp is now filled 802// fmt.Println(resp) 803// } 804func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1Request(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (req *request.Request, output *OutputService4TestShapeOutputService4TestCaseOperation1Output) { 805 op := &request.Operation{ 806 Name: opOutputService4TestCaseOperation1, 807 HTTPPath: "/", 808 } 809 810 if input == nil { 811 input = &OutputService4TestShapeOutputService4TestCaseOperation1Input{} 812 } 813 814 output = &OutputService4TestShapeOutputService4TestCaseOperation1Output{} 815 req = c.newRequest(op, input, output) 816 return 817} 818 819// OutputService4TestCaseOperation1 API operation for . 820// 821// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 822// with awserr.Error's Code and Message methods to get detailed information about 823// the error. 824// 825// See the AWS API reference guide for 's 826// API operation OutputService4TestCaseOperation1 for usage and error information. 827func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1(input *OutputService4TestShapeOutputService4TestCaseOperation1Input) (*OutputService4TestShapeOutputService4TestCaseOperation1Output, error) { 828 req, out := c.OutputService4TestCaseOperation1Request(input) 829 return out, req.Send() 830} 831 832// OutputService4TestCaseOperation1WithContext is the same as OutputService4TestCaseOperation1 with the addition of 833// the ability to pass a context and additional request options. 834// 835// See OutputService4TestCaseOperation1 for details on how to use this API operation. 836// 837// The context must be non-nil and will be used for request cancellation. If 838// the context is nil a panic will occur. In the future the SDK may create 839// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 840// for more information on using Contexts. 841func (c *OutputService4ProtocolTest) OutputService4TestCaseOperation1WithContext(ctx aws.Context, input *OutputService4TestShapeOutputService4TestCaseOperation1Input, opts ...request.Option) (*OutputService4TestShapeOutputService4TestCaseOperation1Output, error) { 842 req, out := c.OutputService4TestCaseOperation1Request(input) 843 req.SetContext(ctx) 844 req.ApplyOptions(opts...) 845 return out, req.Send() 846} 847 848type OutputService4TestShapeOutputService4TestCaseOperation1Input struct { 849 _ struct{} `type:"structure"` 850} 851 852type OutputService4TestShapeOutputService4TestCaseOperation1Output struct { 853 _ struct{} `type:"structure"` 854 855 ListMember []*string `locationNameList:"item" type:"list"` 856} 857 858// SetListMember sets the ListMember field's value. 859func (s *OutputService4TestShapeOutputService4TestCaseOperation1Output) SetListMember(v []*string) *OutputService4TestShapeOutputService4TestCaseOperation1Output { 860 s.ListMember = v 861 return s 862} 863 864// OutputService5ProtocolTest provides the API operation methods for making requests to 865// . See this package's package overview docs 866// for details on the service. 867// 868// OutputService5ProtocolTest methods are safe to use concurrently. It is not safe to 869// modify mutate any of the struct's properties though. 870type OutputService5ProtocolTest struct { 871 *client.Client 872} 873 874// New creates a new instance of the OutputService5ProtocolTest client with a session. 875// If additional configuration is needed for the client instance use the optional 876// aws.Config parameter to add your extra config. 877// 878// Example: 879// // Create a OutputService5ProtocolTest client from just a session. 880// svc := outputservice5protocoltest.New(mySession) 881// 882// // Create a OutputService5ProtocolTest client with additional configuration 883// svc := outputservice5protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 884func NewOutputService5ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *OutputService5ProtocolTest { 885 c := p.ClientConfig("outputservice5protocoltest", cfgs...) 886 return newOutputService5ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 887} 888 889// newClient creates, initializes and returns a new service client instance. 890func newOutputService5ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *OutputService5ProtocolTest { 891 svc := &OutputService5ProtocolTest{ 892 Client: client.New( 893 cfg, 894 metadata.ClientInfo{ 895 ServiceName: "OutputService5ProtocolTest", 896 ServiceID: "OutputService5ProtocolTest", 897 SigningName: signingName, 898 SigningRegion: signingRegion, 899 Endpoint: endpoint, 900 APIVersion: "", 901 }, 902 handlers, 903 ), 904 } 905 906 // Handlers 907 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 908 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 909 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 910 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 911 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 912 913 return svc 914} 915 916// newRequest creates a new request for a OutputService5ProtocolTest operation and runs any 917// custom request initialization. 918func (c *OutputService5ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 919 req := c.NewRequest(op, params, data) 920 921 return req 922} 923 924const opOutputService5TestCaseOperation1 = "OperationName" 925 926// OutputService5TestCaseOperation1Request generates a "aws/request.Request" representing the 927// client's request for the OutputService5TestCaseOperation1 operation. The "output" return 928// value will be populated with the request's response once the request completes 929// successfuly. 930// 931// Use "Send" method on the returned Request to send the API call to the service. 932// the "output" return value is not valid until after Send returns without error. 933// 934// See OutputService5TestCaseOperation1 for more information on using the OutputService5TestCaseOperation1 935// API call, and error handling. 936// 937// This method is useful when you want to inject custom logic or configuration 938// into the SDK's request lifecycle. Such as custom headers, or retry logic. 939// 940// 941// // Example sending a request using the OutputService5TestCaseOperation1Request method. 942// req, resp := client.OutputService5TestCaseOperation1Request(params) 943// 944// err := req.Send() 945// if err == nil { // resp is now filled 946// fmt.Println(resp) 947// } 948func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1Request(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (req *request.Request, output *OutputService5TestShapeOutputService5TestCaseOperation1Output) { 949 op := &request.Operation{ 950 Name: opOutputService5TestCaseOperation1, 951 HTTPPath: "/", 952 } 953 954 if input == nil { 955 input = &OutputService5TestShapeOutputService5TestCaseOperation1Input{} 956 } 957 958 output = &OutputService5TestShapeOutputService5TestCaseOperation1Output{} 959 req = c.newRequest(op, input, output) 960 return 961} 962 963// OutputService5TestCaseOperation1 API operation for . 964// 965// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 966// with awserr.Error's Code and Message methods to get detailed information about 967// the error. 968// 969// See the AWS API reference guide for 's 970// API operation OutputService5TestCaseOperation1 for usage and error information. 971func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1(input *OutputService5TestShapeOutputService5TestCaseOperation1Input) (*OutputService5TestShapeOutputService5TestCaseOperation1Output, error) { 972 req, out := c.OutputService5TestCaseOperation1Request(input) 973 return out, req.Send() 974} 975 976// OutputService5TestCaseOperation1WithContext is the same as OutputService5TestCaseOperation1 with the addition of 977// the ability to pass a context and additional request options. 978// 979// See OutputService5TestCaseOperation1 for details on how to use this API operation. 980// 981// The context must be non-nil and will be used for request cancellation. If 982// the context is nil a panic will occur. In the future the SDK may create 983// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 984// for more information on using Contexts. 985func (c *OutputService5ProtocolTest) OutputService5TestCaseOperation1WithContext(ctx aws.Context, input *OutputService5TestShapeOutputService5TestCaseOperation1Input, opts ...request.Option) (*OutputService5TestShapeOutputService5TestCaseOperation1Output, error) { 986 req, out := c.OutputService5TestCaseOperation1Request(input) 987 req.SetContext(ctx) 988 req.ApplyOptions(opts...) 989 return out, req.Send() 990} 991 992type OutputService5TestShapeOutputService5TestCaseOperation1Input struct { 993 _ struct{} `type:"structure"` 994} 995 996type OutputService5TestShapeOutputService5TestCaseOperation1Output struct { 997 _ struct{} `type:"structure"` 998 999 ListMember []*string `type:"list" flattened:"true"` 1000} 1001 1002// SetListMember sets the ListMember field's value. 1003func (s *OutputService5TestShapeOutputService5TestCaseOperation1Output) SetListMember(v []*string) *OutputService5TestShapeOutputService5TestCaseOperation1Output { 1004 s.ListMember = v 1005 return s 1006} 1007 1008// OutputService6ProtocolTest provides the API operation methods for making requests to 1009// . See this package's package overview docs 1010// for details on the service. 1011// 1012// OutputService6ProtocolTest methods are safe to use concurrently. It is not safe to 1013// modify mutate any of the struct's properties though. 1014type OutputService6ProtocolTest struct { 1015 *client.Client 1016} 1017 1018// New creates a new instance of the OutputService6ProtocolTest client with a session. 1019// If additional configuration is needed for the client instance use the optional 1020// aws.Config parameter to add your extra config. 1021// 1022// Example: 1023// // Create a OutputService6ProtocolTest client from just a session. 1024// svc := outputservice6protocoltest.New(mySession) 1025// 1026// // Create a OutputService6ProtocolTest client with additional configuration 1027// svc := outputservice6protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1028func NewOutputService6ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *OutputService6ProtocolTest { 1029 c := p.ClientConfig("outputservice6protocoltest", cfgs...) 1030 return newOutputService6ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1031} 1032 1033// newClient creates, initializes and returns a new service client instance. 1034func newOutputService6ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *OutputService6ProtocolTest { 1035 svc := &OutputService6ProtocolTest{ 1036 Client: client.New( 1037 cfg, 1038 metadata.ClientInfo{ 1039 ServiceName: "OutputService6ProtocolTest", 1040 ServiceID: "OutputService6ProtocolTest", 1041 SigningName: signingName, 1042 SigningRegion: signingRegion, 1043 Endpoint: endpoint, 1044 APIVersion: "", 1045 }, 1046 handlers, 1047 ), 1048 } 1049 1050 // Handlers 1051 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1052 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1053 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1054 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1055 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1056 1057 return svc 1058} 1059 1060// newRequest creates a new request for a OutputService6ProtocolTest operation and runs any 1061// custom request initialization. 1062func (c *OutputService6ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1063 req := c.NewRequest(op, params, data) 1064 1065 return req 1066} 1067 1068const opOutputService6TestCaseOperation1 = "OperationName" 1069 1070// OutputService6TestCaseOperation1Request generates a "aws/request.Request" representing the 1071// client's request for the OutputService6TestCaseOperation1 operation. The "output" return 1072// value will be populated with the request's response once the request completes 1073// successfuly. 1074// 1075// Use "Send" method on the returned Request to send the API call to the service. 1076// the "output" return value is not valid until after Send returns without error. 1077// 1078// See OutputService6TestCaseOperation1 for more information on using the OutputService6TestCaseOperation1 1079// API call, and error handling. 1080// 1081// This method is useful when you want to inject custom logic or configuration 1082// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1083// 1084// 1085// // Example sending a request using the OutputService6TestCaseOperation1Request method. 1086// req, resp := client.OutputService6TestCaseOperation1Request(params) 1087// 1088// err := req.Send() 1089// if err == nil { // resp is now filled 1090// fmt.Println(resp) 1091// } 1092func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1Request(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (req *request.Request, output *OutputService6TestShapeOutputService6TestCaseOperation1Output) { 1093 op := &request.Operation{ 1094 Name: opOutputService6TestCaseOperation1, 1095 HTTPPath: "/", 1096 } 1097 1098 if input == nil { 1099 input = &OutputService6TestShapeOutputService6TestCaseOperation1Input{} 1100 } 1101 1102 output = &OutputService6TestShapeOutputService6TestCaseOperation1Output{} 1103 req = c.newRequest(op, input, output) 1104 return 1105} 1106 1107// OutputService6TestCaseOperation1 API operation for . 1108// 1109// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1110// with awserr.Error's Code and Message methods to get detailed information about 1111// the error. 1112// 1113// See the AWS API reference guide for 's 1114// API operation OutputService6TestCaseOperation1 for usage and error information. 1115func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1(input *OutputService6TestShapeOutputService6TestCaseOperation1Input) (*OutputService6TestShapeOutputService6TestCaseOperation1Output, error) { 1116 req, out := c.OutputService6TestCaseOperation1Request(input) 1117 return out, req.Send() 1118} 1119 1120// OutputService6TestCaseOperation1WithContext is the same as OutputService6TestCaseOperation1 with the addition of 1121// the ability to pass a context and additional request options. 1122// 1123// See OutputService6TestCaseOperation1 for details on how to use this API operation. 1124// 1125// The context must be non-nil and will be used for request cancellation. If 1126// the context is nil a panic will occur. In the future the SDK may create 1127// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1128// for more information on using Contexts. 1129func (c *OutputService6ProtocolTest) OutputService6TestCaseOperation1WithContext(ctx aws.Context, input *OutputService6TestShapeOutputService6TestCaseOperation1Input, opts ...request.Option) (*OutputService6TestShapeOutputService6TestCaseOperation1Output, error) { 1130 req, out := c.OutputService6TestCaseOperation1Request(input) 1131 req.SetContext(ctx) 1132 req.ApplyOptions(opts...) 1133 return out, req.Send() 1134} 1135 1136type OutputService6TestShapeOutputService6TestCaseOperation1Input struct { 1137 _ struct{} `type:"structure"` 1138} 1139 1140type OutputService6TestShapeOutputService6TestCaseOperation1Output struct { 1141 _ struct{} `type:"structure"` 1142 1143 Map map[string]*OutputService6TestShapeSingleStructure `type:"map"` 1144} 1145 1146// SetMap sets the Map field's value. 1147func (s *OutputService6TestShapeOutputService6TestCaseOperation1Output) SetMap(v map[string]*OutputService6TestShapeSingleStructure) *OutputService6TestShapeOutputService6TestCaseOperation1Output { 1148 s.Map = v 1149 return s 1150} 1151 1152type OutputService6TestShapeSingleStructure struct { 1153 _ struct{} `type:"structure"` 1154 1155 Foo *string `locationName:"foo" type:"string"` 1156} 1157 1158// SetFoo sets the Foo field's value. 1159func (s *OutputService6TestShapeSingleStructure) SetFoo(v string) *OutputService6TestShapeSingleStructure { 1160 s.Foo = &v 1161 return s 1162} 1163 1164// OutputService7ProtocolTest provides the API operation methods for making requests to 1165// . See this package's package overview docs 1166// for details on the service. 1167// 1168// OutputService7ProtocolTest methods are safe to use concurrently. It is not safe to 1169// modify mutate any of the struct's properties though. 1170type OutputService7ProtocolTest struct { 1171 *client.Client 1172} 1173 1174// New creates a new instance of the OutputService7ProtocolTest client with a session. 1175// If additional configuration is needed for the client instance use the optional 1176// aws.Config parameter to add your extra config. 1177// 1178// Example: 1179// // Create a OutputService7ProtocolTest client from just a session. 1180// svc := outputservice7protocoltest.New(mySession) 1181// 1182// // Create a OutputService7ProtocolTest client with additional configuration 1183// svc := outputservice7protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1184func NewOutputService7ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *OutputService7ProtocolTest { 1185 c := p.ClientConfig("outputservice7protocoltest", cfgs...) 1186 return newOutputService7ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1187} 1188 1189// newClient creates, initializes and returns a new service client instance. 1190func newOutputService7ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *OutputService7ProtocolTest { 1191 svc := &OutputService7ProtocolTest{ 1192 Client: client.New( 1193 cfg, 1194 metadata.ClientInfo{ 1195 ServiceName: "OutputService7ProtocolTest", 1196 ServiceID: "OutputService7ProtocolTest", 1197 SigningName: signingName, 1198 SigningRegion: signingRegion, 1199 Endpoint: endpoint, 1200 APIVersion: "", 1201 }, 1202 handlers, 1203 ), 1204 } 1205 1206 // Handlers 1207 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1208 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1209 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1210 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1211 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1212 1213 return svc 1214} 1215 1216// newRequest creates a new request for a OutputService7ProtocolTest operation and runs any 1217// custom request initialization. 1218func (c *OutputService7ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1219 req := c.NewRequest(op, params, data) 1220 1221 return req 1222} 1223 1224const opOutputService7TestCaseOperation1 = "OperationName" 1225 1226// OutputService7TestCaseOperation1Request generates a "aws/request.Request" representing the 1227// client's request for the OutputService7TestCaseOperation1 operation. The "output" return 1228// value will be populated with the request's response once the request completes 1229// successfuly. 1230// 1231// Use "Send" method on the returned Request to send the API call to the service. 1232// the "output" return value is not valid until after Send returns without error. 1233// 1234// See OutputService7TestCaseOperation1 for more information on using the OutputService7TestCaseOperation1 1235// API call, and error handling. 1236// 1237// This method is useful when you want to inject custom logic or configuration 1238// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1239// 1240// 1241// // Example sending a request using the OutputService7TestCaseOperation1Request method. 1242// req, resp := client.OutputService7TestCaseOperation1Request(params) 1243// 1244// err := req.Send() 1245// if err == nil { // resp is now filled 1246// fmt.Println(resp) 1247// } 1248func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1Request(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (req *request.Request, output *OutputService7TestShapeOutputService7TestCaseOperation1Output) { 1249 op := &request.Operation{ 1250 Name: opOutputService7TestCaseOperation1, 1251 HTTPPath: "/", 1252 } 1253 1254 if input == nil { 1255 input = &OutputService7TestShapeOutputService7TestCaseOperation1Input{} 1256 } 1257 1258 output = &OutputService7TestShapeOutputService7TestCaseOperation1Output{} 1259 req = c.newRequest(op, input, output) 1260 return 1261} 1262 1263// OutputService7TestCaseOperation1 API operation for . 1264// 1265// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1266// with awserr.Error's Code and Message methods to get detailed information about 1267// the error. 1268// 1269// See the AWS API reference guide for 's 1270// API operation OutputService7TestCaseOperation1 for usage and error information. 1271func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1(input *OutputService7TestShapeOutputService7TestCaseOperation1Input) (*OutputService7TestShapeOutputService7TestCaseOperation1Output, error) { 1272 req, out := c.OutputService7TestCaseOperation1Request(input) 1273 return out, req.Send() 1274} 1275 1276// OutputService7TestCaseOperation1WithContext is the same as OutputService7TestCaseOperation1 with the addition of 1277// the ability to pass a context and additional request options. 1278// 1279// See OutputService7TestCaseOperation1 for details on how to use this API operation. 1280// 1281// The context must be non-nil and will be used for request cancellation. If 1282// the context is nil a panic will occur. In the future the SDK may create 1283// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1284// for more information on using Contexts. 1285func (c *OutputService7ProtocolTest) OutputService7TestCaseOperation1WithContext(ctx aws.Context, input *OutputService7TestShapeOutputService7TestCaseOperation1Input, opts ...request.Option) (*OutputService7TestShapeOutputService7TestCaseOperation1Output, error) { 1286 req, out := c.OutputService7TestCaseOperation1Request(input) 1287 req.SetContext(ctx) 1288 req.ApplyOptions(opts...) 1289 return out, req.Send() 1290} 1291 1292type OutputService7TestShapeOutputService7TestCaseOperation1Input struct { 1293 _ struct{} `type:"structure"` 1294} 1295 1296type OutputService7TestShapeOutputService7TestCaseOperation1Output struct { 1297 _ struct{} `type:"structure"` 1298 1299 Map map[string]*string `type:"map" flattened:"true"` 1300} 1301 1302// SetMap sets the Map field's value. 1303func (s *OutputService7TestShapeOutputService7TestCaseOperation1Output) SetMap(v map[string]*string) *OutputService7TestShapeOutputService7TestCaseOperation1Output { 1304 s.Map = v 1305 return s 1306} 1307 1308// OutputService8ProtocolTest provides the API operation methods for making requests to 1309// . See this package's package overview docs 1310// for details on the service. 1311// 1312// OutputService8ProtocolTest methods are safe to use concurrently. It is not safe to 1313// modify mutate any of the struct's properties though. 1314type OutputService8ProtocolTest struct { 1315 *client.Client 1316} 1317 1318// New creates a new instance of the OutputService8ProtocolTest client with a session. 1319// If additional configuration is needed for the client instance use the optional 1320// aws.Config parameter to add your extra config. 1321// 1322// Example: 1323// // Create a OutputService8ProtocolTest client from just a session. 1324// svc := outputservice8protocoltest.New(mySession) 1325// 1326// // Create a OutputService8ProtocolTest client with additional configuration 1327// svc := outputservice8protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1328func NewOutputService8ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *OutputService8ProtocolTest { 1329 c := p.ClientConfig("outputservice8protocoltest", cfgs...) 1330 return newOutputService8ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1331} 1332 1333// newClient creates, initializes and returns a new service client instance. 1334func newOutputService8ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *OutputService8ProtocolTest { 1335 svc := &OutputService8ProtocolTest{ 1336 Client: client.New( 1337 cfg, 1338 metadata.ClientInfo{ 1339 ServiceName: "OutputService8ProtocolTest", 1340 ServiceID: "OutputService8ProtocolTest", 1341 SigningName: signingName, 1342 SigningRegion: signingRegion, 1343 Endpoint: endpoint, 1344 APIVersion: "", 1345 }, 1346 handlers, 1347 ), 1348 } 1349 1350 // Handlers 1351 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1352 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1353 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1354 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1355 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1356 1357 return svc 1358} 1359 1360// newRequest creates a new request for a OutputService8ProtocolTest operation and runs any 1361// custom request initialization. 1362func (c *OutputService8ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1363 req := c.NewRequest(op, params, data) 1364 1365 return req 1366} 1367 1368const opOutputService8TestCaseOperation1 = "OperationName" 1369 1370// OutputService8TestCaseOperation1Request generates a "aws/request.Request" representing the 1371// client's request for the OutputService8TestCaseOperation1 operation. The "output" return 1372// value will be populated with the request's response once the request completes 1373// successfuly. 1374// 1375// Use "Send" method on the returned Request to send the API call to the service. 1376// the "output" return value is not valid until after Send returns without error. 1377// 1378// See OutputService8TestCaseOperation1 for more information on using the OutputService8TestCaseOperation1 1379// API call, and error handling. 1380// 1381// This method is useful when you want to inject custom logic or configuration 1382// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1383// 1384// 1385// // Example sending a request using the OutputService8TestCaseOperation1Request method. 1386// req, resp := client.OutputService8TestCaseOperation1Request(params) 1387// 1388// err := req.Send() 1389// if err == nil { // resp is now filled 1390// fmt.Println(resp) 1391// } 1392func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1Request(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (req *request.Request, output *OutputService8TestShapeOutputService8TestCaseOperation1Output) { 1393 op := &request.Operation{ 1394 Name: opOutputService8TestCaseOperation1, 1395 HTTPPath: "/", 1396 } 1397 1398 if input == nil { 1399 input = &OutputService8TestShapeOutputService8TestCaseOperation1Input{} 1400 } 1401 1402 output = &OutputService8TestShapeOutputService8TestCaseOperation1Output{} 1403 req = c.newRequest(op, input, output) 1404 return 1405} 1406 1407// OutputService8TestCaseOperation1 API operation for . 1408// 1409// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1410// with awserr.Error's Code and Message methods to get detailed information about 1411// the error. 1412// 1413// See the AWS API reference guide for 's 1414// API operation OutputService8TestCaseOperation1 for usage and error information. 1415func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1(input *OutputService8TestShapeOutputService8TestCaseOperation1Input) (*OutputService8TestShapeOutputService8TestCaseOperation1Output, error) { 1416 req, out := c.OutputService8TestCaseOperation1Request(input) 1417 return out, req.Send() 1418} 1419 1420// OutputService8TestCaseOperation1WithContext is the same as OutputService8TestCaseOperation1 with the addition of 1421// the ability to pass a context and additional request options. 1422// 1423// See OutputService8TestCaseOperation1 for details on how to use this API operation. 1424// 1425// The context must be non-nil and will be used for request cancellation. If 1426// the context is nil a panic will occur. In the future the SDK may create 1427// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1428// for more information on using Contexts. 1429func (c *OutputService8ProtocolTest) OutputService8TestCaseOperation1WithContext(ctx aws.Context, input *OutputService8TestShapeOutputService8TestCaseOperation1Input, opts ...request.Option) (*OutputService8TestShapeOutputService8TestCaseOperation1Output, error) { 1430 req, out := c.OutputService8TestCaseOperation1Request(input) 1431 req.SetContext(ctx) 1432 req.ApplyOptions(opts...) 1433 return out, req.Send() 1434} 1435 1436type OutputService8TestShapeOutputService8TestCaseOperation1Input struct { 1437 _ struct{} `type:"structure"` 1438} 1439 1440type OutputService8TestShapeOutputService8TestCaseOperation1Output struct { 1441 _ struct{} `type:"structure"` 1442 1443 Map map[string]*string `locationNameKey:"foo" locationNameValue:"bar" type:"map"` 1444} 1445 1446// SetMap sets the Map field's value. 1447func (s *OutputService8TestShapeOutputService8TestCaseOperation1Output) SetMap(v map[string]*string) *OutputService8TestShapeOutputService8TestCaseOperation1Output { 1448 s.Map = v 1449 return s 1450} 1451 1452// OutputService9ProtocolTest provides the API operation methods for making requests to 1453// . See this package's package overview docs 1454// for details on the service. 1455// 1456// OutputService9ProtocolTest methods are safe to use concurrently. It is not safe to 1457// modify mutate any of the struct's properties though. 1458type OutputService9ProtocolTest struct { 1459 *client.Client 1460} 1461 1462// New creates a new instance of the OutputService9ProtocolTest client with a session. 1463// If additional configuration is needed for the client instance use the optional 1464// aws.Config parameter to add your extra config. 1465// 1466// Example: 1467// // Create a OutputService9ProtocolTest client from just a session. 1468// svc := outputservice9protocoltest.New(mySession) 1469// 1470// // Create a OutputService9ProtocolTest client with additional configuration 1471// svc := outputservice9protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1472func NewOutputService9ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *OutputService9ProtocolTest { 1473 c := p.ClientConfig("outputservice9protocoltest", cfgs...) 1474 return newOutputService9ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1475} 1476 1477// newClient creates, initializes and returns a new service client instance. 1478func newOutputService9ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *OutputService9ProtocolTest { 1479 svc := &OutputService9ProtocolTest{ 1480 Client: client.New( 1481 cfg, 1482 metadata.ClientInfo{ 1483 ServiceName: "OutputService9ProtocolTest", 1484 ServiceID: "OutputService9ProtocolTest", 1485 SigningName: signingName, 1486 SigningRegion: signingRegion, 1487 Endpoint: endpoint, 1488 APIVersion: "", 1489 }, 1490 handlers, 1491 ), 1492 } 1493 1494 // Handlers 1495 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1496 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1497 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1498 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1499 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1500 1501 return svc 1502} 1503 1504// newRequest creates a new request for a OutputService9ProtocolTest operation and runs any 1505// custom request initialization. 1506func (c *OutputService9ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1507 req := c.NewRequest(op, params, data) 1508 1509 return req 1510} 1511 1512const opOutputService9TestCaseOperation1 = "OperationName" 1513 1514// OutputService9TestCaseOperation1Request generates a "aws/request.Request" representing the 1515// client's request for the OutputService9TestCaseOperation1 operation. The "output" return 1516// value will be populated with the request's response once the request completes 1517// successfuly. 1518// 1519// Use "Send" method on the returned Request to send the API call to the service. 1520// the "output" return value is not valid until after Send returns without error. 1521// 1522// See OutputService9TestCaseOperation1 for more information on using the OutputService9TestCaseOperation1 1523// API call, and error handling. 1524// 1525// This method is useful when you want to inject custom logic or configuration 1526// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1527// 1528// 1529// // Example sending a request using the OutputService9TestCaseOperation1Request method. 1530// req, resp := client.OutputService9TestCaseOperation1Request(params) 1531// 1532// err := req.Send() 1533// if err == nil { // resp is now filled 1534// fmt.Println(resp) 1535// } 1536func (c *OutputService9ProtocolTest) OutputService9TestCaseOperation1Request(input *OutputService9TestShapeOutputService9TestCaseOperation1Input) (req *request.Request, output *OutputService9TestShapeOutputService9TestCaseOperation1Output) { 1537 op := &request.Operation{ 1538 Name: opOutputService9TestCaseOperation1, 1539 HTTPPath: "/", 1540 } 1541 1542 if input == nil { 1543 input = &OutputService9TestShapeOutputService9TestCaseOperation1Input{} 1544 } 1545 1546 output = &OutputService9TestShapeOutputService9TestCaseOperation1Output{} 1547 req = c.newRequest(op, input, output) 1548 return 1549} 1550 1551// OutputService9TestCaseOperation1 API operation for . 1552// 1553// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1554// with awserr.Error's Code and Message methods to get detailed information about 1555// the error. 1556// 1557// See the AWS API reference guide for 's 1558// API operation OutputService9TestCaseOperation1 for usage and error information. 1559func (c *OutputService9ProtocolTest) OutputService9TestCaseOperation1(input *OutputService9TestShapeOutputService9TestCaseOperation1Input) (*OutputService9TestShapeOutputService9TestCaseOperation1Output, error) { 1560 req, out := c.OutputService9TestCaseOperation1Request(input) 1561 return out, req.Send() 1562} 1563 1564// OutputService9TestCaseOperation1WithContext is the same as OutputService9TestCaseOperation1 with the addition of 1565// the ability to pass a context and additional request options. 1566// 1567// See OutputService9TestCaseOperation1 for details on how to use this API operation. 1568// 1569// The context must be non-nil and will be used for request cancellation. If 1570// the context is nil a panic will occur. In the future the SDK may create 1571// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1572// for more information on using Contexts. 1573func (c *OutputService9ProtocolTest) OutputService9TestCaseOperation1WithContext(ctx aws.Context, input *OutputService9TestShapeOutputService9TestCaseOperation1Input, opts ...request.Option) (*OutputService9TestShapeOutputService9TestCaseOperation1Output, error) { 1574 req, out := c.OutputService9TestCaseOperation1Request(input) 1575 req.SetContext(ctx) 1576 req.ApplyOptions(opts...) 1577 return out, req.Send() 1578} 1579 1580type OutputService9TestShapeOutputService9TestCaseOperation1Input struct { 1581 _ struct{} `type:"structure"` 1582} 1583 1584type OutputService9TestShapeOutputService9TestCaseOperation1Output struct { 1585 _ struct{} `type:"structure" payload:"Data"` 1586 1587 Data *OutputService9TestShapeSingleStructure `type:"structure"` 1588 1589 Header *string `location:"header" locationName:"X-Foo" type:"string"` 1590} 1591 1592// SetData sets the Data field's value. 1593func (s *OutputService9TestShapeOutputService9TestCaseOperation1Output) SetData(v *OutputService9TestShapeSingleStructure) *OutputService9TestShapeOutputService9TestCaseOperation1Output { 1594 s.Data = v 1595 return s 1596} 1597 1598// SetHeader sets the Header field's value. 1599func (s *OutputService9TestShapeOutputService9TestCaseOperation1Output) SetHeader(v string) *OutputService9TestShapeOutputService9TestCaseOperation1Output { 1600 s.Header = &v 1601 return s 1602} 1603 1604type OutputService9TestShapeSingleStructure struct { 1605 _ struct{} `type:"structure"` 1606 1607 Foo *string `type:"string"` 1608} 1609 1610// SetFoo sets the Foo field's value. 1611func (s *OutputService9TestShapeSingleStructure) SetFoo(v string) *OutputService9TestShapeSingleStructure { 1612 s.Foo = &v 1613 return s 1614} 1615 1616// OutputService10ProtocolTest provides the API operation methods for making requests to 1617// . See this package's package overview docs 1618// for details on the service. 1619// 1620// OutputService10ProtocolTest methods are safe to use concurrently. It is not safe to 1621// modify mutate any of the struct's properties though. 1622type OutputService10ProtocolTest struct { 1623 *client.Client 1624} 1625 1626// New creates a new instance of the OutputService10ProtocolTest client with a session. 1627// If additional configuration is needed for the client instance use the optional 1628// aws.Config parameter to add your extra config. 1629// 1630// Example: 1631// // Create a OutputService10ProtocolTest client from just a session. 1632// svc := outputservice10protocoltest.New(mySession) 1633// 1634// // Create a OutputService10ProtocolTest client with additional configuration 1635// svc := outputservice10protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1636func NewOutputService10ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *OutputService10ProtocolTest { 1637 c := p.ClientConfig("outputservice10protocoltest", cfgs...) 1638 return newOutputService10ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1639} 1640 1641// newClient creates, initializes and returns a new service client instance. 1642func newOutputService10ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *OutputService10ProtocolTest { 1643 svc := &OutputService10ProtocolTest{ 1644 Client: client.New( 1645 cfg, 1646 metadata.ClientInfo{ 1647 ServiceName: "OutputService10ProtocolTest", 1648 ServiceID: "OutputService10ProtocolTest", 1649 SigningName: signingName, 1650 SigningRegion: signingRegion, 1651 Endpoint: endpoint, 1652 APIVersion: "", 1653 }, 1654 handlers, 1655 ), 1656 } 1657 1658 // Handlers 1659 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1660 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1661 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1662 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1663 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1664 1665 return svc 1666} 1667 1668// newRequest creates a new request for a OutputService10ProtocolTest operation and runs any 1669// custom request initialization. 1670func (c *OutputService10ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1671 req := c.NewRequest(op, params, data) 1672 1673 return req 1674} 1675 1676const opOutputService10TestCaseOperation1 = "OperationName" 1677 1678// OutputService10TestCaseOperation1Request generates a "aws/request.Request" representing the 1679// client's request for the OutputService10TestCaseOperation1 operation. The "output" return 1680// value will be populated with the request's response once the request completes 1681// successfuly. 1682// 1683// Use "Send" method on the returned Request to send the API call to the service. 1684// the "output" return value is not valid until after Send returns without error. 1685// 1686// See OutputService10TestCaseOperation1 for more information on using the OutputService10TestCaseOperation1 1687// API call, and error handling. 1688// 1689// This method is useful when you want to inject custom logic or configuration 1690// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1691// 1692// 1693// // Example sending a request using the OutputService10TestCaseOperation1Request method. 1694// req, resp := client.OutputService10TestCaseOperation1Request(params) 1695// 1696// err := req.Send() 1697// if err == nil { // resp is now filled 1698// fmt.Println(resp) 1699// } 1700func (c *OutputService10ProtocolTest) OutputService10TestCaseOperation1Request(input *OutputService10TestShapeOutputService10TestCaseOperation1Input) (req *request.Request, output *OutputService10TestShapeOutputService10TestCaseOperation1Output) { 1701 op := &request.Operation{ 1702 Name: opOutputService10TestCaseOperation1, 1703 HTTPPath: "/", 1704 } 1705 1706 if input == nil { 1707 input = &OutputService10TestShapeOutputService10TestCaseOperation1Input{} 1708 } 1709 1710 output = &OutputService10TestShapeOutputService10TestCaseOperation1Output{} 1711 req = c.newRequest(op, input, output) 1712 return 1713} 1714 1715// OutputService10TestCaseOperation1 API operation for . 1716// 1717// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1718// with awserr.Error's Code and Message methods to get detailed information about 1719// the error. 1720// 1721// See the AWS API reference guide for 's 1722// API operation OutputService10TestCaseOperation1 for usage and error information. 1723func (c *OutputService10ProtocolTest) OutputService10TestCaseOperation1(input *OutputService10TestShapeOutputService10TestCaseOperation1Input) (*OutputService10TestShapeOutputService10TestCaseOperation1Output, error) { 1724 req, out := c.OutputService10TestCaseOperation1Request(input) 1725 return out, req.Send() 1726} 1727 1728// OutputService10TestCaseOperation1WithContext is the same as OutputService10TestCaseOperation1 with the addition of 1729// the ability to pass a context and additional request options. 1730// 1731// See OutputService10TestCaseOperation1 for details on how to use this API operation. 1732// 1733// The context must be non-nil and will be used for request cancellation. If 1734// the context is nil a panic will occur. In the future the SDK may create 1735// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1736// for more information on using Contexts. 1737func (c *OutputService10ProtocolTest) OutputService10TestCaseOperation1WithContext(ctx aws.Context, input *OutputService10TestShapeOutputService10TestCaseOperation1Input, opts ...request.Option) (*OutputService10TestShapeOutputService10TestCaseOperation1Output, error) { 1738 req, out := c.OutputService10TestCaseOperation1Request(input) 1739 req.SetContext(ctx) 1740 req.ApplyOptions(opts...) 1741 return out, req.Send() 1742} 1743 1744type OutputService10TestShapeOutputService10TestCaseOperation1Input struct { 1745 _ struct{} `type:"structure"` 1746} 1747 1748type OutputService10TestShapeOutputService10TestCaseOperation1Output struct { 1749 _ struct{} `type:"structure" payload:"Stream"` 1750 1751 Stream []byte `type:"blob"` 1752} 1753 1754// SetStream sets the Stream field's value. 1755func (s *OutputService10TestShapeOutputService10TestCaseOperation1Output) SetStream(v []byte) *OutputService10TestShapeOutputService10TestCaseOperation1Output { 1756 s.Stream = v 1757 return s 1758} 1759 1760// OutputService11ProtocolTest provides the API operation methods for making requests to 1761// . See this package's package overview docs 1762// for details on the service. 1763// 1764// OutputService11ProtocolTest methods are safe to use concurrently. It is not safe to 1765// modify mutate any of the struct's properties though. 1766type OutputService11ProtocolTest struct { 1767 *client.Client 1768} 1769 1770// New creates a new instance of the OutputService11ProtocolTest client with a session. 1771// If additional configuration is needed for the client instance use the optional 1772// aws.Config parameter to add your extra config. 1773// 1774// Example: 1775// // Create a OutputService11ProtocolTest client from just a session. 1776// svc := outputservice11protocoltest.New(mySession) 1777// 1778// // Create a OutputService11ProtocolTest client with additional configuration 1779// svc := outputservice11protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1780func NewOutputService11ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *OutputService11ProtocolTest { 1781 c := p.ClientConfig("outputservice11protocoltest", cfgs...) 1782 return newOutputService11ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1783} 1784 1785// newClient creates, initializes and returns a new service client instance. 1786func newOutputService11ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *OutputService11ProtocolTest { 1787 svc := &OutputService11ProtocolTest{ 1788 Client: client.New( 1789 cfg, 1790 metadata.ClientInfo{ 1791 ServiceName: "OutputService11ProtocolTest", 1792 ServiceID: "OutputService11ProtocolTest", 1793 SigningName: signingName, 1794 SigningRegion: signingRegion, 1795 Endpoint: endpoint, 1796 APIVersion: "", 1797 }, 1798 handlers, 1799 ), 1800 } 1801 1802 // Handlers 1803 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 1804 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 1805 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 1806 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 1807 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 1808 1809 return svc 1810} 1811 1812// newRequest creates a new request for a OutputService11ProtocolTest operation and runs any 1813// custom request initialization. 1814func (c *OutputService11ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 1815 req := c.NewRequest(op, params, data) 1816 1817 return req 1818} 1819 1820const opOutputService11TestCaseOperation1 = "OperationName" 1821 1822// OutputService11TestCaseOperation1Request generates a "aws/request.Request" representing the 1823// client's request for the OutputService11TestCaseOperation1 operation. The "output" return 1824// value will be populated with the request's response once the request completes 1825// successfuly. 1826// 1827// Use "Send" method on the returned Request to send the API call to the service. 1828// the "output" return value is not valid until after Send returns without error. 1829// 1830// See OutputService11TestCaseOperation1 for more information on using the OutputService11TestCaseOperation1 1831// API call, and error handling. 1832// 1833// This method is useful when you want to inject custom logic or configuration 1834// into the SDK's request lifecycle. Such as custom headers, or retry logic. 1835// 1836// 1837// // Example sending a request using the OutputService11TestCaseOperation1Request method. 1838// req, resp := client.OutputService11TestCaseOperation1Request(params) 1839// 1840// err := req.Send() 1841// if err == nil { // resp is now filled 1842// fmt.Println(resp) 1843// } 1844func (c *OutputService11ProtocolTest) OutputService11TestCaseOperation1Request(input *OutputService11TestShapeOutputService11TestCaseOperation1Input) (req *request.Request, output *OutputService11TestShapeOutputService11TestCaseOperation1Output) { 1845 op := &request.Operation{ 1846 Name: opOutputService11TestCaseOperation1, 1847 HTTPPath: "/", 1848 } 1849 1850 if input == nil { 1851 input = &OutputService11TestShapeOutputService11TestCaseOperation1Input{} 1852 } 1853 1854 output = &OutputService11TestShapeOutputService11TestCaseOperation1Output{} 1855 req = c.newRequest(op, input, output) 1856 return 1857} 1858 1859// OutputService11TestCaseOperation1 API operation for . 1860// 1861// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 1862// with awserr.Error's Code and Message methods to get detailed information about 1863// the error. 1864// 1865// See the AWS API reference guide for 's 1866// API operation OutputService11TestCaseOperation1 for usage and error information. 1867func (c *OutputService11ProtocolTest) OutputService11TestCaseOperation1(input *OutputService11TestShapeOutputService11TestCaseOperation1Input) (*OutputService11TestShapeOutputService11TestCaseOperation1Output, error) { 1868 req, out := c.OutputService11TestCaseOperation1Request(input) 1869 return out, req.Send() 1870} 1871 1872// OutputService11TestCaseOperation1WithContext is the same as OutputService11TestCaseOperation1 with the addition of 1873// the ability to pass a context and additional request options. 1874// 1875// See OutputService11TestCaseOperation1 for details on how to use this API operation. 1876// 1877// The context must be non-nil and will be used for request cancellation. If 1878// the context is nil a panic will occur. In the future the SDK may create 1879// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 1880// for more information on using Contexts. 1881func (c *OutputService11ProtocolTest) OutputService11TestCaseOperation1WithContext(ctx aws.Context, input *OutputService11TestShapeOutputService11TestCaseOperation1Input, opts ...request.Option) (*OutputService11TestShapeOutputService11TestCaseOperation1Output, error) { 1882 req, out := c.OutputService11TestCaseOperation1Request(input) 1883 req.SetContext(ctx) 1884 req.ApplyOptions(opts...) 1885 return out, req.Send() 1886} 1887 1888type OutputService11TestShapeOutputService11TestCaseOperation1Input struct { 1889 _ struct{} `type:"structure"` 1890} 1891 1892type OutputService11TestShapeOutputService11TestCaseOperation1Output struct { 1893 _ struct{} `type:"structure"` 1894 1895 Char *string `location:"header" locationName:"x-char" type:"character"` 1896 1897 Double *float64 `location:"header" locationName:"x-double" type:"double"` 1898 1899 FalseBool *bool `location:"header" locationName:"x-false-bool" type:"boolean"` 1900 1901 Float *float64 `location:"header" locationName:"x-float" type:"float"` 1902 1903 Integer *int64 `location:"header" locationName:"x-int" type:"integer"` 1904 1905 Long *int64 `location:"header" locationName:"x-long" type:"long"` 1906 1907 Str *string `location:"header" locationName:"x-str" type:"string"` 1908 1909 Timestamp *time.Time `location:"header" locationName:"x-timestamp" type:"timestamp" timestampFormat:"iso8601"` 1910 1911 TrueBool *bool `location:"header" locationName:"x-true-bool" type:"boolean"` 1912} 1913 1914// SetChar sets the Char field's value. 1915func (s *OutputService11TestShapeOutputService11TestCaseOperation1Output) SetChar(v string) *OutputService11TestShapeOutputService11TestCaseOperation1Output { 1916 s.Char = &v 1917 return s 1918} 1919 1920// SetDouble sets the Double field's value. 1921func (s *OutputService11TestShapeOutputService11TestCaseOperation1Output) SetDouble(v float64) *OutputService11TestShapeOutputService11TestCaseOperation1Output { 1922 s.Double = &v 1923 return s 1924} 1925 1926// SetFalseBool sets the FalseBool field's value. 1927func (s *OutputService11TestShapeOutputService11TestCaseOperation1Output) SetFalseBool(v bool) *OutputService11TestShapeOutputService11TestCaseOperation1Output { 1928 s.FalseBool = &v 1929 return s 1930} 1931 1932// SetFloat sets the Float field's value. 1933func (s *OutputService11TestShapeOutputService11TestCaseOperation1Output) SetFloat(v float64) *OutputService11TestShapeOutputService11TestCaseOperation1Output { 1934 s.Float = &v 1935 return s 1936} 1937 1938// SetInteger sets the Integer field's value. 1939func (s *OutputService11TestShapeOutputService11TestCaseOperation1Output) SetInteger(v int64) *OutputService11TestShapeOutputService11TestCaseOperation1Output { 1940 s.Integer = &v 1941 return s 1942} 1943 1944// SetLong sets the Long field's value. 1945func (s *OutputService11TestShapeOutputService11TestCaseOperation1Output) SetLong(v int64) *OutputService11TestShapeOutputService11TestCaseOperation1Output { 1946 s.Long = &v 1947 return s 1948} 1949 1950// SetStr sets the Str field's value. 1951func (s *OutputService11TestShapeOutputService11TestCaseOperation1Output) SetStr(v string) *OutputService11TestShapeOutputService11TestCaseOperation1Output { 1952 s.Str = &v 1953 return s 1954} 1955 1956// SetTimestamp sets the Timestamp field's value. 1957func (s *OutputService11TestShapeOutputService11TestCaseOperation1Output) SetTimestamp(v time.Time) *OutputService11TestShapeOutputService11TestCaseOperation1Output { 1958 s.Timestamp = &v 1959 return s 1960} 1961 1962// SetTrueBool sets the TrueBool field's value. 1963func (s *OutputService11TestShapeOutputService11TestCaseOperation1Output) SetTrueBool(v bool) *OutputService11TestShapeOutputService11TestCaseOperation1Output { 1964 s.TrueBool = &v 1965 return s 1966} 1967 1968// OutputService12ProtocolTest provides the API operation methods for making requests to 1969// . See this package's package overview docs 1970// for details on the service. 1971// 1972// OutputService12ProtocolTest methods are safe to use concurrently. It is not safe to 1973// modify mutate any of the struct's properties though. 1974type OutputService12ProtocolTest struct { 1975 *client.Client 1976} 1977 1978// New creates a new instance of the OutputService12ProtocolTest client with a session. 1979// If additional configuration is needed for the client instance use the optional 1980// aws.Config parameter to add your extra config. 1981// 1982// Example: 1983// // Create a OutputService12ProtocolTest client from just a session. 1984// svc := outputservice12protocoltest.New(mySession) 1985// 1986// // Create a OutputService12ProtocolTest client with additional configuration 1987// svc := outputservice12protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 1988func NewOutputService12ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *OutputService12ProtocolTest { 1989 c := p.ClientConfig("outputservice12protocoltest", cfgs...) 1990 return newOutputService12ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 1991} 1992 1993// newClient creates, initializes and returns a new service client instance. 1994func newOutputService12ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *OutputService12ProtocolTest { 1995 svc := &OutputService12ProtocolTest{ 1996 Client: client.New( 1997 cfg, 1998 metadata.ClientInfo{ 1999 ServiceName: "OutputService12ProtocolTest", 2000 ServiceID: "OutputService12ProtocolTest", 2001 SigningName: signingName, 2002 SigningRegion: signingRegion, 2003 Endpoint: endpoint, 2004 APIVersion: "", 2005 }, 2006 handlers, 2007 ), 2008 } 2009 2010 // Handlers 2011 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2012 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 2013 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 2014 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 2015 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 2016 2017 return svc 2018} 2019 2020// newRequest creates a new request for a OutputService12ProtocolTest operation and runs any 2021// custom request initialization. 2022func (c *OutputService12ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2023 req := c.NewRequest(op, params, data) 2024 2025 return req 2026} 2027 2028const opOutputService12TestCaseOperation1 = "OperationName" 2029 2030// OutputService12TestCaseOperation1Request generates a "aws/request.Request" representing the 2031// client's request for the OutputService12TestCaseOperation1 operation. The "output" return 2032// value will be populated with the request's response once the request completes 2033// successfuly. 2034// 2035// Use "Send" method on the returned Request to send the API call to the service. 2036// the "output" return value is not valid until after Send returns without error. 2037// 2038// See OutputService12TestCaseOperation1 for more information on using the OutputService12TestCaseOperation1 2039// API call, and error handling. 2040// 2041// This method is useful when you want to inject custom logic or configuration 2042// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2043// 2044// 2045// // Example sending a request using the OutputService12TestCaseOperation1Request method. 2046// req, resp := client.OutputService12TestCaseOperation1Request(params) 2047// 2048// err := req.Send() 2049// if err == nil { // resp is now filled 2050// fmt.Println(resp) 2051// } 2052func (c *OutputService12ProtocolTest) OutputService12TestCaseOperation1Request(input *OutputService12TestShapeOutputService12TestCaseOperation1Input) (req *request.Request, output *OutputService12TestShapeOutputService12TestCaseOperation1Output) { 2053 op := &request.Operation{ 2054 Name: opOutputService12TestCaseOperation1, 2055 HTTPPath: "/", 2056 } 2057 2058 if input == nil { 2059 input = &OutputService12TestShapeOutputService12TestCaseOperation1Input{} 2060 } 2061 2062 output = &OutputService12TestShapeOutputService12TestCaseOperation1Output{} 2063 req = c.newRequest(op, input, output) 2064 return 2065} 2066 2067// OutputService12TestCaseOperation1 API operation for . 2068// 2069// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2070// with awserr.Error's Code and Message methods to get detailed information about 2071// the error. 2072// 2073// See the AWS API reference guide for 's 2074// API operation OutputService12TestCaseOperation1 for usage and error information. 2075func (c *OutputService12ProtocolTest) OutputService12TestCaseOperation1(input *OutputService12TestShapeOutputService12TestCaseOperation1Input) (*OutputService12TestShapeOutputService12TestCaseOperation1Output, error) { 2076 req, out := c.OutputService12TestCaseOperation1Request(input) 2077 return out, req.Send() 2078} 2079 2080// OutputService12TestCaseOperation1WithContext is the same as OutputService12TestCaseOperation1 with the addition of 2081// the ability to pass a context and additional request options. 2082// 2083// See OutputService12TestCaseOperation1 for details on how to use this API operation. 2084// 2085// The context must be non-nil and will be used for request cancellation. If 2086// the context is nil a panic will occur. In the future the SDK may create 2087// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2088// for more information on using Contexts. 2089func (c *OutputService12ProtocolTest) OutputService12TestCaseOperation1WithContext(ctx aws.Context, input *OutputService12TestShapeOutputService12TestCaseOperation1Input, opts ...request.Option) (*OutputService12TestShapeOutputService12TestCaseOperation1Output, error) { 2090 req, out := c.OutputService12TestCaseOperation1Request(input) 2091 req.SetContext(ctx) 2092 req.ApplyOptions(opts...) 2093 return out, req.Send() 2094} 2095 2096type OutputService12TestShapeOutputService12TestCaseOperation1Input struct { 2097 _ struct{} `type:"structure"` 2098} 2099 2100type OutputService12TestShapeOutputService12TestCaseOperation1Output struct { 2101 _ struct{} `type:"structure"` 2102 2103 Foo *string `type:"string"` 2104} 2105 2106// SetFoo sets the Foo field's value. 2107func (s *OutputService12TestShapeOutputService12TestCaseOperation1Output) SetFoo(v string) *OutputService12TestShapeOutputService12TestCaseOperation1Output { 2108 s.Foo = &v 2109 return s 2110} 2111 2112// OutputService13ProtocolTest provides the API operation methods for making requests to 2113// . See this package's package overview docs 2114// for details on the service. 2115// 2116// OutputService13ProtocolTest methods are safe to use concurrently. It is not safe to 2117// modify mutate any of the struct's properties though. 2118type OutputService13ProtocolTest struct { 2119 *client.Client 2120} 2121 2122// New creates a new instance of the OutputService13ProtocolTest client with a session. 2123// If additional configuration is needed for the client instance use the optional 2124// aws.Config parameter to add your extra config. 2125// 2126// Example: 2127// // Create a OutputService13ProtocolTest client from just a session. 2128// svc := outputservice13protocoltest.New(mySession) 2129// 2130// // Create a OutputService13ProtocolTest client with additional configuration 2131// svc := outputservice13protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2132func NewOutputService13ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *OutputService13ProtocolTest { 2133 c := p.ClientConfig("outputservice13protocoltest", cfgs...) 2134 return newOutputService13ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2135} 2136 2137// newClient creates, initializes and returns a new service client instance. 2138func newOutputService13ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *OutputService13ProtocolTest { 2139 svc := &OutputService13ProtocolTest{ 2140 Client: client.New( 2141 cfg, 2142 metadata.ClientInfo{ 2143 ServiceName: "OutputService13ProtocolTest", 2144 ServiceID: "OutputService13ProtocolTest", 2145 SigningName: signingName, 2146 SigningRegion: signingRegion, 2147 Endpoint: endpoint, 2148 APIVersion: "", 2149 }, 2150 handlers, 2151 ), 2152 } 2153 2154 // Handlers 2155 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2156 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 2157 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 2158 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 2159 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 2160 2161 return svc 2162} 2163 2164// newRequest creates a new request for a OutputService13ProtocolTest operation and runs any 2165// custom request initialization. 2166func (c *OutputService13ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2167 req := c.NewRequest(op, params, data) 2168 2169 return req 2170} 2171 2172const opOutputService13TestCaseOperation1 = "OperationName" 2173 2174// OutputService13TestCaseOperation1Request generates a "aws/request.Request" representing the 2175// client's request for the OutputService13TestCaseOperation1 operation. The "output" return 2176// value will be populated with the request's response once the request completes 2177// successfuly. 2178// 2179// Use "Send" method on the returned Request to send the API call to the service. 2180// the "output" return value is not valid until after Send returns without error. 2181// 2182// See OutputService13TestCaseOperation1 for more information on using the OutputService13TestCaseOperation1 2183// API call, and error handling. 2184// 2185// This method is useful when you want to inject custom logic or configuration 2186// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2187// 2188// 2189// // Example sending a request using the OutputService13TestCaseOperation1Request method. 2190// req, resp := client.OutputService13TestCaseOperation1Request(params) 2191// 2192// err := req.Send() 2193// if err == nil { // resp is now filled 2194// fmt.Println(resp) 2195// } 2196func (c *OutputService13ProtocolTest) OutputService13TestCaseOperation1Request(input *OutputService13TestShapeOutputService13TestCaseOperation1Input) (req *request.Request, output *OutputService13TestShapeOutputService13TestCaseOperation2Input) { 2197 op := &request.Operation{ 2198 Name: opOutputService13TestCaseOperation1, 2199 HTTPMethod: "POST", 2200 HTTPPath: "/path", 2201 } 2202 2203 if input == nil { 2204 input = &OutputService13TestShapeOutputService13TestCaseOperation1Input{} 2205 } 2206 2207 output = &OutputService13TestShapeOutputService13TestCaseOperation2Input{} 2208 req = c.newRequest(op, input, output) 2209 return 2210} 2211 2212// OutputService13TestCaseOperation1 API operation for . 2213// 2214// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2215// with awserr.Error's Code and Message methods to get detailed information about 2216// the error. 2217// 2218// See the AWS API reference guide for 's 2219// API operation OutputService13TestCaseOperation1 for usage and error information. 2220func (c *OutputService13ProtocolTest) OutputService13TestCaseOperation1(input *OutputService13TestShapeOutputService13TestCaseOperation1Input) (*OutputService13TestShapeOutputService13TestCaseOperation2Input, error) { 2221 req, out := c.OutputService13TestCaseOperation1Request(input) 2222 return out, req.Send() 2223} 2224 2225// OutputService13TestCaseOperation1WithContext is the same as OutputService13TestCaseOperation1 with the addition of 2226// the ability to pass a context and additional request options. 2227// 2228// See OutputService13TestCaseOperation1 for details on how to use this API operation. 2229// 2230// The context must be non-nil and will be used for request cancellation. If 2231// the context is nil a panic will occur. In the future the SDK may create 2232// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2233// for more information on using Contexts. 2234func (c *OutputService13ProtocolTest) OutputService13TestCaseOperation1WithContext(ctx aws.Context, input *OutputService13TestShapeOutputService13TestCaseOperation1Input, opts ...request.Option) (*OutputService13TestShapeOutputService13TestCaseOperation2Input, error) { 2235 req, out := c.OutputService13TestCaseOperation1Request(input) 2236 req.SetContext(ctx) 2237 req.ApplyOptions(opts...) 2238 return out, req.Send() 2239} 2240 2241const opOutputService13TestCaseOperation2 = "OperationName" 2242 2243// OutputService13TestCaseOperation2Request generates a "aws/request.Request" representing the 2244// client's request for the OutputService13TestCaseOperation2 operation. The "output" return 2245// value will be populated with the request's response once the request completes 2246// successfuly. 2247// 2248// Use "Send" method on the returned Request to send the API call to the service. 2249// the "output" return value is not valid until after Send returns without error. 2250// 2251// See OutputService13TestCaseOperation2 for more information on using the OutputService13TestCaseOperation2 2252// API call, and error handling. 2253// 2254// This method is useful when you want to inject custom logic or configuration 2255// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2256// 2257// 2258// // Example sending a request using the OutputService13TestCaseOperation2Request method. 2259// req, resp := client.OutputService13TestCaseOperation2Request(params) 2260// 2261// err := req.Send() 2262// if err == nil { // resp is now filled 2263// fmt.Println(resp) 2264// } 2265func (c *OutputService13ProtocolTest) OutputService13TestCaseOperation2Request(input *OutputService13TestShapeOutputService13TestCaseOperation2Input) (req *request.Request, output *OutputService13TestShapeOutputService13TestCaseOperation2Output) { 2266 op := &request.Operation{ 2267 Name: opOutputService13TestCaseOperation2, 2268 HTTPMethod: "POST", 2269 HTTPPath: "/path", 2270 } 2271 2272 if input == nil { 2273 input = &OutputService13TestShapeOutputService13TestCaseOperation2Input{} 2274 } 2275 2276 output = &OutputService13TestShapeOutputService13TestCaseOperation2Output{} 2277 req = c.newRequest(op, input, output) 2278 req.Handlers.Unmarshal.Remove(restxml.UnmarshalHandler) 2279 req.Handlers.Unmarshal.PushBackNamed(protocol.UnmarshalDiscardBodyHandler) 2280 return 2281} 2282 2283// OutputService13TestCaseOperation2 API operation for . 2284// 2285// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2286// with awserr.Error's Code and Message methods to get detailed information about 2287// the error. 2288// 2289// See the AWS API reference guide for 's 2290// API operation OutputService13TestCaseOperation2 for usage and error information. 2291func (c *OutputService13ProtocolTest) OutputService13TestCaseOperation2(input *OutputService13TestShapeOutputService13TestCaseOperation2Input) (*OutputService13TestShapeOutputService13TestCaseOperation2Output, error) { 2292 req, out := c.OutputService13TestCaseOperation2Request(input) 2293 return out, req.Send() 2294} 2295 2296// OutputService13TestCaseOperation2WithContext is the same as OutputService13TestCaseOperation2 with the addition of 2297// the ability to pass a context and additional request options. 2298// 2299// See OutputService13TestCaseOperation2 for details on how to use this API operation. 2300// 2301// The context must be non-nil and will be used for request cancellation. If 2302// the context is nil a panic will occur. In the future the SDK may create 2303// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2304// for more information on using Contexts. 2305func (c *OutputService13ProtocolTest) OutputService13TestCaseOperation2WithContext(ctx aws.Context, input *OutputService13TestShapeOutputService13TestCaseOperation2Input, opts ...request.Option) (*OutputService13TestShapeOutputService13TestCaseOperation2Output, error) { 2306 req, out := c.OutputService13TestCaseOperation2Request(input) 2307 req.SetContext(ctx) 2308 req.ApplyOptions(opts...) 2309 return out, req.Send() 2310} 2311 2312type OutputService13TestShapeOutputService13TestCaseOperation1Input struct { 2313 _ struct{} `type:"structure"` 2314} 2315 2316type OutputService13TestShapeOutputService13TestCaseOperation2Input struct { 2317 _ struct{} `type:"structure"` 2318 2319 FooEnum *string `type:"string" enum:"OutputService13TestShapeRESTJSONEnumType"` 2320 2321 HeaderEnum *string `location:"header" locationName:"x-amz-enum" type:"string" enum:"OutputService13TestShapeRESTJSONEnumType"` 2322 2323 ListEnums []*string `type:"list"` 2324} 2325 2326// SetFooEnum sets the FooEnum field's value. 2327func (s *OutputService13TestShapeOutputService13TestCaseOperation2Input) SetFooEnum(v string) *OutputService13TestShapeOutputService13TestCaseOperation2Input { 2328 s.FooEnum = &v 2329 return s 2330} 2331 2332// SetHeaderEnum sets the HeaderEnum field's value. 2333func (s *OutputService13TestShapeOutputService13TestCaseOperation2Input) SetHeaderEnum(v string) *OutputService13TestShapeOutputService13TestCaseOperation2Input { 2334 s.HeaderEnum = &v 2335 return s 2336} 2337 2338// SetListEnums sets the ListEnums field's value. 2339func (s *OutputService13TestShapeOutputService13TestCaseOperation2Input) SetListEnums(v []*string) *OutputService13TestShapeOutputService13TestCaseOperation2Input { 2340 s.ListEnums = v 2341 return s 2342} 2343 2344type OutputService13TestShapeOutputService13TestCaseOperation2Output struct { 2345 _ struct{} `type:"structure"` 2346} 2347 2348const ( 2349 // RESTJSONEnumTypeFoo is a OutputService13TestShapeRESTJSONEnumType enum value 2350 RESTJSONEnumTypeFoo = "foo" 2351 2352 // RESTJSONEnumTypeBar is a OutputService13TestShapeRESTJSONEnumType enum value 2353 RESTJSONEnumTypeBar = "bar" 2354 2355 // RESTJSONEnumType0 is a OutputService13TestShapeRESTJSONEnumType enum value 2356 RESTJSONEnumType0 = "0" 2357 2358 // RESTJSONEnumType1 is a OutputService13TestShapeRESTJSONEnumType enum value 2359 RESTJSONEnumType1 = "1" 2360) 2361 2362// OutputService14ProtocolTest provides the API operation methods for making requests to 2363// . See this package's package overview docs 2364// for details on the service. 2365// 2366// OutputService14ProtocolTest methods are safe to use concurrently. It is not safe to 2367// modify mutate any of the struct's properties though. 2368type OutputService14ProtocolTest struct { 2369 *client.Client 2370} 2371 2372// New creates a new instance of the OutputService14ProtocolTest client with a session. 2373// If additional configuration is needed for the client instance use the optional 2374// aws.Config parameter to add your extra config. 2375// 2376// Example: 2377// // Create a OutputService14ProtocolTest client from just a session. 2378// svc := outputservice14protocoltest.New(mySession) 2379// 2380// // Create a OutputService14ProtocolTest client with additional configuration 2381// svc := outputservice14protocoltest.New(mySession, aws.NewConfig().WithRegion("us-west-2")) 2382func NewOutputService14ProtocolTest(p client.ConfigProvider, cfgs ...*aws.Config) *OutputService14ProtocolTest { 2383 c := p.ClientConfig("outputservice14protocoltest", cfgs...) 2384 return newOutputService14ProtocolTestClient(*c.Config, c.Handlers, c.Endpoint, c.SigningRegion, c.SigningName) 2385} 2386 2387// newClient creates, initializes and returns a new service client instance. 2388func newOutputService14ProtocolTestClient(cfg aws.Config, handlers request.Handlers, endpoint, signingRegion, signingName string) *OutputService14ProtocolTest { 2389 svc := &OutputService14ProtocolTest{ 2390 Client: client.New( 2391 cfg, 2392 metadata.ClientInfo{ 2393 ServiceName: "OutputService14ProtocolTest", 2394 ServiceID: "OutputService14ProtocolTest", 2395 SigningName: signingName, 2396 SigningRegion: signingRegion, 2397 Endpoint: endpoint, 2398 APIVersion: "", 2399 }, 2400 handlers, 2401 ), 2402 } 2403 2404 // Handlers 2405 svc.Handlers.Sign.PushBackNamed(v4.SignRequestHandler) 2406 svc.Handlers.Build.PushBackNamed(restxml.BuildHandler) 2407 svc.Handlers.Unmarshal.PushBackNamed(restxml.UnmarshalHandler) 2408 svc.Handlers.UnmarshalMeta.PushBackNamed(restxml.UnmarshalMetaHandler) 2409 svc.Handlers.UnmarshalError.PushBackNamed(restxml.UnmarshalErrorHandler) 2410 2411 return svc 2412} 2413 2414// newRequest creates a new request for a OutputService14ProtocolTest operation and runs any 2415// custom request initialization. 2416func (c *OutputService14ProtocolTest) newRequest(op *request.Operation, params, data interface{}) *request.Request { 2417 req := c.NewRequest(op, params, data) 2418 2419 return req 2420} 2421 2422const opOutputService14TestCaseOperation1 = "OperationName" 2423 2424// OutputService14TestCaseOperation1Request generates a "aws/request.Request" representing the 2425// client's request for the OutputService14TestCaseOperation1 operation. The "output" return 2426// value will be populated with the request's response once the request completes 2427// successfuly. 2428// 2429// Use "Send" method on the returned Request to send the API call to the service. 2430// the "output" return value is not valid until after Send returns without error. 2431// 2432// See OutputService14TestCaseOperation1 for more information on using the OutputService14TestCaseOperation1 2433// API call, and error handling. 2434// 2435// This method is useful when you want to inject custom logic or configuration 2436// into the SDK's request lifecycle. Such as custom headers, or retry logic. 2437// 2438// 2439// // Example sending a request using the OutputService14TestCaseOperation1Request method. 2440// req, resp := client.OutputService14TestCaseOperation1Request(params) 2441// 2442// err := req.Send() 2443// if err == nil { // resp is now filled 2444// fmt.Println(resp) 2445// } 2446func (c *OutputService14ProtocolTest) OutputService14TestCaseOperation1Request(input *OutputService14TestShapeOutputService14TestCaseOperation1Input) (req *request.Request, output *OutputService14TestShapeOutputService14TestCaseOperation1Output) { 2447 op := &request.Operation{ 2448 Name: opOutputService14TestCaseOperation1, 2449 HTTPMethod: "GET", 2450 HTTPPath: "/path", 2451 } 2452 2453 if input == nil { 2454 input = &OutputService14TestShapeOutputService14TestCaseOperation1Input{} 2455 } 2456 2457 output = &OutputService14TestShapeOutputService14TestCaseOperation1Output{} 2458 req = c.newRequest(op, input, output) 2459 return 2460} 2461 2462// OutputService14TestCaseOperation1 API operation for . 2463// 2464// Returns awserr.Error for service API and SDK errors. Use runtime type assertions 2465// with awserr.Error's Code and Message methods to get detailed information about 2466// the error. 2467// 2468// See the AWS API reference guide for 's 2469// API operation OutputService14TestCaseOperation1 for usage and error information. 2470func (c *OutputService14ProtocolTest) OutputService14TestCaseOperation1(input *OutputService14TestShapeOutputService14TestCaseOperation1Input) (*OutputService14TestShapeOutputService14TestCaseOperation1Output, error) { 2471 req, out := c.OutputService14TestCaseOperation1Request(input) 2472 return out, req.Send() 2473} 2474 2475// OutputService14TestCaseOperation1WithContext is the same as OutputService14TestCaseOperation1 with the addition of 2476// the ability to pass a context and additional request options. 2477// 2478// See OutputService14TestCaseOperation1 for details on how to use this API operation. 2479// 2480// The context must be non-nil and will be used for request cancellation. If 2481// the context is nil a panic will occur. In the future the SDK may create 2482// sub-contexts for http.Requests. See https://golang.org/pkg/context/ 2483// for more information on using Contexts. 2484func (c *OutputService14ProtocolTest) OutputService14TestCaseOperation1WithContext(ctx aws.Context, input *OutputService14TestShapeOutputService14TestCaseOperation1Input, opts ...request.Option) (*OutputService14TestShapeOutputService14TestCaseOperation1Output, error) { 2485 req, out := c.OutputService14TestCaseOperation1Request(input) 2486 req.SetContext(ctx) 2487 req.ApplyOptions(opts...) 2488 return out, req.Send() 2489} 2490 2491type OutputService14TestShapeItemDetailShape struct { 2492 _ struct{} `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"` 2493 2494 ID *string `type:"string"` 2495 2496 // Type is a required field 2497 Type *string `locationName:"xsi:type" type:"string" xmlAttribute:"true" required:"true" enum:"OutputService14TestShapeItemType"` 2498} 2499 2500// SetID sets the ID field's value. 2501func (s *OutputService14TestShapeItemDetailShape) SetID(v string) *OutputService14TestShapeItemDetailShape { 2502 s.ID = &v 2503 return s 2504} 2505 2506// SetType sets the Type field's value. 2507func (s *OutputService14TestShapeItemDetailShape) SetType(v string) *OutputService14TestShapeItemDetailShape { 2508 s.Type = &v 2509 return s 2510} 2511 2512type OutputService14TestShapeItemShape struct { 2513 _ struct{} `type:"structure"` 2514 2515 ItemDetail *OutputService14TestShapeItemDetailShape `type:"structure" xmlPrefix:"xsi" xmlURI:"http://www.w3.org/2001/XMLSchema-instance"` 2516} 2517 2518// SetItemDetail sets the ItemDetail field's value. 2519func (s *OutputService14TestShapeItemShape) SetItemDetail(v *OutputService14TestShapeItemDetailShape) *OutputService14TestShapeItemShape { 2520 s.ItemDetail = v 2521 return s 2522} 2523 2524type OutputService14TestShapeOutputService14TestCaseOperation1Input struct { 2525 _ struct{} `type:"structure"` 2526} 2527 2528type OutputService14TestShapeOutputService14TestCaseOperation1Output struct { 2529 _ struct{} `type:"structure"` 2530 2531 ListItems []*OutputService14TestShapeItemShape `locationName:"ItemsList" locationNameList:"Item" type:"list"` 2532} 2533 2534// SetListItems sets the ListItems field's value. 2535func (s *OutputService14TestShapeOutputService14TestCaseOperation1Output) SetListItems(v []*OutputService14TestShapeItemShape) *OutputService14TestShapeOutputService14TestCaseOperation1Output { 2536 s.ListItems = v 2537 return s 2538} 2539 2540const ( 2541 // ItemTypeType1 is a OutputService14TestShapeItemType enum value 2542 ItemTypeType1 = "Type1" 2543 2544 // ItemTypeType2 is a OutputService14TestShapeItemType enum value 2545 ItemTypeType2 = "Type2" 2546 2547 // ItemTypeType3 is a OutputService14TestShapeItemType enum value 2548 ItemTypeType3 = "Type3" 2549) 2550 2551// 2552// Tests begin here 2553// 2554 2555func TestOutputService1ProtocolTestScalarMembersCase1(t *testing.T) { 2556 svc := NewOutputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2557 2558 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><Timestamp>2015-01-25T08:00:00Z</Timestamp></OperationNameResponse>")) 2559 req, out := svc.OutputService1TestCaseOperation1Request(nil) 2560 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 2561 2562 // set headers 2563 req.HTTPResponse.Header.Set("ImaHeader", "test") 2564 req.HTTPResponse.Header.Set("X-Foo", "abc") 2565 2566 // unmarshal response 2567 restxml.UnmarshalMeta(req) 2568 restxml.Unmarshal(req) 2569 if req.Error != nil { 2570 t.Errorf("expect not error, got %v", req.Error) 2571 } 2572 2573 // assert response 2574 if out == nil { 2575 t.Errorf("expect not to be nil") 2576 } 2577 if e, a := "a", *out.Char; e != a { 2578 t.Errorf("expect %v, got %v", e, a) 2579 } 2580 if e, a := 1.3, *out.Double; e != a { 2581 t.Errorf("expect %v, got %v", e, a) 2582 } 2583 if e, a := false, *out.FalseBool; e != a { 2584 t.Errorf("expect %v, got %v", e, a) 2585 } 2586 if e, a := 1.2, *out.Float; e != a { 2587 t.Errorf("expect %v, got %v", e, a) 2588 } 2589 if e, a := "test", *out.ImaHeader; e != a { 2590 t.Errorf("expect %v, got %v", e, a) 2591 } 2592 if e, a := "abc", *out.ImaHeaderLocation; e != a { 2593 t.Errorf("expect %v, got %v", e, a) 2594 } 2595 if e, a := int64(200), *out.Long; e != a { 2596 t.Errorf("expect %v, got %v", e, a) 2597 } 2598 if e, a := int64(123), *out.Num; e != a { 2599 t.Errorf("expect %v, got %v", e, a) 2600 } 2601 if e, a := "myname", *out.Str; e != a { 2602 t.Errorf("expect %v, got %v", e, a) 2603 } 2604 if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.UTC().String(); e != a { 2605 t.Errorf("expect %v, got %v", e, a) 2606 } 2607 if e, a := true, *out.TrueBool; e != a { 2608 t.Errorf("expect %v, got %v", e, a) 2609 } 2610 2611} 2612 2613func TestOutputService1ProtocolTestScalarMembersCase2(t *testing.T) { 2614 svc := NewOutputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2615 2616 buf := bytes.NewReader([]byte("<OperationNameResponse><Str></Str><FooNum>123</FooNum><FalseBool>false</FalseBool><TrueBool>true</TrueBool><Float>1.2</Float><Double>1.3</Double><Long>200</Long><Char>a</Char><Timestamp>2015-01-25T08:00:00Z</Timestamp></OperationNameResponse>")) 2617 req, out := svc.OutputService1TestCaseOperation2Request(nil) 2618 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 2619 2620 // set headers 2621 req.HTTPResponse.Header.Set("ImaHeader", "test") 2622 req.HTTPResponse.Header.Set("X-Foo", "abc") 2623 2624 // unmarshal response 2625 restxml.UnmarshalMeta(req) 2626 restxml.Unmarshal(req) 2627 if req.Error != nil { 2628 t.Errorf("expect not error, got %v", req.Error) 2629 } 2630 2631 // assert response 2632 if out == nil { 2633 t.Errorf("expect not to be nil") 2634 } 2635 if e, a := "a", *out.Char; e != a { 2636 t.Errorf("expect %v, got %v", e, a) 2637 } 2638 if e, a := 1.3, *out.Double; e != a { 2639 t.Errorf("expect %v, got %v", e, a) 2640 } 2641 if e, a := false, *out.FalseBool; e != a { 2642 t.Errorf("expect %v, got %v", e, a) 2643 } 2644 if e, a := 1.2, *out.Float; e != a { 2645 t.Errorf("expect %v, got %v", e, a) 2646 } 2647 if e, a := "test", *out.ImaHeader; e != a { 2648 t.Errorf("expect %v, got %v", e, a) 2649 } 2650 if e, a := "abc", *out.ImaHeaderLocation; e != a { 2651 t.Errorf("expect %v, got %v", e, a) 2652 } 2653 if e, a := int64(200), *out.Long; e != a { 2654 t.Errorf("expect %v, got %v", e, a) 2655 } 2656 if e, a := int64(123), *out.Num; e != a { 2657 t.Errorf("expect %v, got %v", e, a) 2658 } 2659 if e, a := "", *out.Str; e != a { 2660 t.Errorf("expect %v, got %v", e, a) 2661 } 2662 if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.UTC().String(); e != a { 2663 t.Errorf("expect %v, got %v", e, a) 2664 } 2665 if e, a := true, *out.TrueBool; e != a { 2666 t.Errorf("expect %v, got %v", e, a) 2667 } 2668 2669} 2670 2671func TestOutputService1ProtocolTestScalarMembersCase3(t *testing.T) { 2672 svc := NewOutputService1ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2673 2674 buf := bytes.NewReader([]byte("<OperationNameResponse><Blobs><member>dmFsdWU=</member><member>dmFsdWUy</member></Blobs><Timestamps><member>2015-01-25T08:00:00Z</member><member>2015-01-25T08:00:01Z</member></Timestamps></OperationNameResponse>")) 2675 req, out := svc.OutputService1TestCaseOperation3Request(nil) 2676 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 2677 2678 // set headers 2679 2680 // unmarshal response 2681 restxml.UnmarshalMeta(req) 2682 restxml.Unmarshal(req) 2683 if req.Error != nil { 2684 t.Errorf("expect not error, got %v", req.Error) 2685 } 2686 2687 // assert response 2688 if out == nil { 2689 t.Errorf("expect not to be nil") 2690 } 2691 if e, a := "value", string(out.Blobs[0]); e != a { 2692 t.Errorf("expect %v, got %v", e, a) 2693 } 2694 if e, a := "value2", string(out.Blobs[1]); e != a { 2695 t.Errorf("expect %v, got %v", e, a) 2696 } 2697 if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamps[0].UTC().String(); e != a { 2698 t.Errorf("expect %v, got %v", e, a) 2699 } 2700 if e, a := time.Unix(1.422172801e+09, 0).UTC().String(), out.Timestamps[1].UTC().String(); e != a { 2701 t.Errorf("expect %v, got %v", e, a) 2702 } 2703 2704} 2705 2706func TestOutputService2ProtocolTestBlobCase1(t *testing.T) { 2707 svc := NewOutputService2ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2708 2709 buf := bytes.NewReader([]byte("<OperationNameResult><Blob>dmFsdWU=</Blob></OperationNameResult>")) 2710 req, out := svc.OutputService2TestCaseOperation1Request(nil) 2711 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 2712 2713 // set headers 2714 2715 // unmarshal response 2716 restxml.UnmarshalMeta(req) 2717 restxml.Unmarshal(req) 2718 if req.Error != nil { 2719 t.Errorf("expect not error, got %v", req.Error) 2720 } 2721 2722 // assert response 2723 if out == nil { 2724 t.Errorf("expect not to be nil") 2725 } 2726 if e, a := "value", string(out.Blob); e != a { 2727 t.Errorf("expect %v, got %v", e, a) 2728 } 2729 2730} 2731 2732func TestOutputService3ProtocolTestListsCase1(t *testing.T) { 2733 svc := NewOutputService3ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2734 2735 buf := bytes.NewReader([]byte("<OperationNameResult><ListMember><member>abc</member><member>123</member></ListMember></OperationNameResult>")) 2736 req, out := svc.OutputService3TestCaseOperation1Request(nil) 2737 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 2738 2739 // set headers 2740 2741 // unmarshal response 2742 restxml.UnmarshalMeta(req) 2743 restxml.Unmarshal(req) 2744 if req.Error != nil { 2745 t.Errorf("expect not error, got %v", req.Error) 2746 } 2747 2748 // assert response 2749 if out == nil { 2750 t.Errorf("expect not to be nil") 2751 } 2752 if e, a := "abc", *out.ListMember[0]; e != a { 2753 t.Errorf("expect %v, got %v", e, a) 2754 } 2755 if e, a := "123", *out.ListMember[1]; e != a { 2756 t.Errorf("expect %v, got %v", e, a) 2757 } 2758 2759} 2760 2761func TestOutputService4ProtocolTestListWithCustomMemberNameCase1(t *testing.T) { 2762 svc := NewOutputService4ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2763 2764 buf := bytes.NewReader([]byte("<OperationNameResult><ListMember><item>abc</item><item>123</item></ListMember></OperationNameResult>")) 2765 req, out := svc.OutputService4TestCaseOperation1Request(nil) 2766 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 2767 2768 // set headers 2769 2770 // unmarshal response 2771 restxml.UnmarshalMeta(req) 2772 restxml.Unmarshal(req) 2773 if req.Error != nil { 2774 t.Errorf("expect not error, got %v", req.Error) 2775 } 2776 2777 // assert response 2778 if out == nil { 2779 t.Errorf("expect not to be nil") 2780 } 2781 if e, a := "abc", *out.ListMember[0]; e != a { 2782 t.Errorf("expect %v, got %v", e, a) 2783 } 2784 if e, a := "123", *out.ListMember[1]; e != a { 2785 t.Errorf("expect %v, got %v", e, a) 2786 } 2787 2788} 2789 2790func TestOutputService5ProtocolTestFlattenedListCase1(t *testing.T) { 2791 svc := NewOutputService5ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2792 2793 buf := bytes.NewReader([]byte("<OperationNameResult><ListMember>abc</ListMember><ListMember>123</ListMember></OperationNameResult>")) 2794 req, out := svc.OutputService5TestCaseOperation1Request(nil) 2795 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 2796 2797 // set headers 2798 2799 // unmarshal response 2800 restxml.UnmarshalMeta(req) 2801 restxml.Unmarshal(req) 2802 if req.Error != nil { 2803 t.Errorf("expect not error, got %v", req.Error) 2804 } 2805 2806 // assert response 2807 if out == nil { 2808 t.Errorf("expect not to be nil") 2809 } 2810 if e, a := "abc", *out.ListMember[0]; e != a { 2811 t.Errorf("expect %v, got %v", e, a) 2812 } 2813 if e, a := "123", *out.ListMember[1]; e != a { 2814 t.Errorf("expect %v, got %v", e, a) 2815 } 2816 2817} 2818 2819func TestOutputService6ProtocolTestNormalMapCase1(t *testing.T) { 2820 svc := NewOutputService6ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2821 2822 buf := bytes.NewReader([]byte("<OperationNameResult><Map><entry><key>qux</key><value><foo>bar</foo></value></entry><entry><key>baz</key><value><foo>bam</foo></value></entry></Map></OperationNameResult>")) 2823 req, out := svc.OutputService6TestCaseOperation1Request(nil) 2824 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 2825 2826 // set headers 2827 2828 // unmarshal response 2829 restxml.UnmarshalMeta(req) 2830 restxml.Unmarshal(req) 2831 if req.Error != nil { 2832 t.Errorf("expect not error, got %v", req.Error) 2833 } 2834 2835 // assert response 2836 if out == nil { 2837 t.Errorf("expect not to be nil") 2838 } 2839 if e, a := "bam", *out.Map["baz"].Foo; e != a { 2840 t.Errorf("expect %v, got %v", e, a) 2841 } 2842 if e, a := "bar", *out.Map["qux"].Foo; e != a { 2843 t.Errorf("expect %v, got %v", e, a) 2844 } 2845 2846} 2847 2848func TestOutputService7ProtocolTestFlattenedMapCase1(t *testing.T) { 2849 svc := NewOutputService7ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2850 2851 buf := bytes.NewReader([]byte("<OperationNameResult><Map><key>qux</key><value>bar</value></Map><Map><key>baz</key><value>bam</value></Map></OperationNameResult>")) 2852 req, out := svc.OutputService7TestCaseOperation1Request(nil) 2853 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 2854 2855 // set headers 2856 2857 // unmarshal response 2858 restxml.UnmarshalMeta(req) 2859 restxml.Unmarshal(req) 2860 if req.Error != nil { 2861 t.Errorf("expect not error, got %v", req.Error) 2862 } 2863 2864 // assert response 2865 if out == nil { 2866 t.Errorf("expect not to be nil") 2867 } 2868 if e, a := "bam", *out.Map["baz"]; e != a { 2869 t.Errorf("expect %v, got %v", e, a) 2870 } 2871 if e, a := "bar", *out.Map["qux"]; e != a { 2872 t.Errorf("expect %v, got %v", e, a) 2873 } 2874 2875} 2876 2877func TestOutputService8ProtocolTestNamedMapCase1(t *testing.T) { 2878 svc := NewOutputService8ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2879 2880 buf := bytes.NewReader([]byte("<OperationNameResult><Map><entry><foo>qux</foo><bar>bar</bar></entry><entry><foo>baz</foo><bar>bam</bar></entry></Map></OperationNameResult>")) 2881 req, out := svc.OutputService8TestCaseOperation1Request(nil) 2882 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 2883 2884 // set headers 2885 2886 // unmarshal response 2887 restxml.UnmarshalMeta(req) 2888 restxml.Unmarshal(req) 2889 if req.Error != nil { 2890 t.Errorf("expect not error, got %v", req.Error) 2891 } 2892 2893 // assert response 2894 if out == nil { 2895 t.Errorf("expect not to be nil") 2896 } 2897 if e, a := "bam", *out.Map["baz"]; e != a { 2898 t.Errorf("expect %v, got %v", e, a) 2899 } 2900 if e, a := "bar", *out.Map["qux"]; e != a { 2901 t.Errorf("expect %v, got %v", e, a) 2902 } 2903 2904} 2905 2906func TestOutputService9ProtocolTestXMLPayloadCase1(t *testing.T) { 2907 svc := NewOutputService9ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2908 2909 buf := bytes.NewReader([]byte("<OperationNameResponse><Foo>abc</Foo></OperationNameResponse>")) 2910 req, out := svc.OutputService9TestCaseOperation1Request(nil) 2911 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 2912 2913 // set headers 2914 req.HTTPResponse.Header.Set("X-Foo", "baz") 2915 2916 // unmarshal response 2917 restxml.UnmarshalMeta(req) 2918 restxml.Unmarshal(req) 2919 if req.Error != nil { 2920 t.Errorf("expect not error, got %v", req.Error) 2921 } 2922 2923 // assert response 2924 if out == nil { 2925 t.Errorf("expect not to be nil") 2926 } 2927 if e, a := "abc", *out.Data.Foo; e != a { 2928 t.Errorf("expect %v, got %v", e, a) 2929 } 2930 if e, a := "baz", *out.Header; e != a { 2931 t.Errorf("expect %v, got %v", e, a) 2932 } 2933 2934} 2935 2936func TestOutputService10ProtocolTestStreamingPayloadCase1(t *testing.T) { 2937 svc := NewOutputService10ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2938 2939 buf := bytes.NewReader([]byte("abc")) 2940 req, out := svc.OutputService10TestCaseOperation1Request(nil) 2941 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 2942 2943 // set headers 2944 2945 // unmarshal response 2946 restxml.UnmarshalMeta(req) 2947 restxml.Unmarshal(req) 2948 if req.Error != nil { 2949 t.Errorf("expect not error, got %v", req.Error) 2950 } 2951 2952 // assert response 2953 if out == nil { 2954 t.Errorf("expect not to be nil") 2955 } 2956 if e, a := "abc", string(out.Stream); e != a { 2957 t.Errorf("expect %v, got %v", e, a) 2958 } 2959 2960} 2961 2962func TestOutputService11ProtocolTestScalarMembersInHeadersCase1(t *testing.T) { 2963 svc := NewOutputService11ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 2964 2965 buf := bytes.NewReader([]byte("")) 2966 req, out := svc.OutputService11TestCaseOperation1Request(nil) 2967 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 2968 2969 // set headers 2970 req.HTTPResponse.Header.Set("x-char", "a") 2971 req.HTTPResponse.Header.Set("x-double", "1.5") 2972 req.HTTPResponse.Header.Set("x-false-bool", "false") 2973 req.HTTPResponse.Header.Set("x-float", "1.5") 2974 req.HTTPResponse.Header.Set("x-int", "1") 2975 req.HTTPResponse.Header.Set("x-long", "100") 2976 req.HTTPResponse.Header.Set("x-str", "string") 2977 req.HTTPResponse.Header.Set("x-timestamp", "Sun, 25 Jan 2015 08:00:00 GMT") 2978 req.HTTPResponse.Header.Set("x-true-bool", "true") 2979 2980 // unmarshal response 2981 restxml.UnmarshalMeta(req) 2982 restxml.Unmarshal(req) 2983 if req.Error != nil { 2984 t.Errorf("expect not error, got %v", req.Error) 2985 } 2986 2987 // assert response 2988 if out == nil { 2989 t.Errorf("expect not to be nil") 2990 } 2991 if e, a := "a", *out.Char; e != a { 2992 t.Errorf("expect %v, got %v", e, a) 2993 } 2994 if e, a := 1.5, *out.Double; e != a { 2995 t.Errorf("expect %v, got %v", e, a) 2996 } 2997 if e, a := false, *out.FalseBool; e != a { 2998 t.Errorf("expect %v, got %v", e, a) 2999 } 3000 if e, a := 1.5, *out.Float; e != a { 3001 t.Errorf("expect %v, got %v", e, a) 3002 } 3003 if e, a := int64(1), *out.Integer; e != a { 3004 t.Errorf("expect %v, got %v", e, a) 3005 } 3006 if e, a := int64(100), *out.Long; e != a { 3007 t.Errorf("expect %v, got %v", e, a) 3008 } 3009 if e, a := "string", *out.Str; e != a { 3010 t.Errorf("expect %v, got %v", e, a) 3011 } 3012 if e, a := time.Unix(1.4221728e+09, 0).UTC().String(), out.Timestamp.UTC().String(); e != a { 3013 t.Errorf("expect %v, got %v", e, a) 3014 } 3015 if e, a := true, *out.TrueBool; e != a { 3016 t.Errorf("expect %v, got %v", e, a) 3017 } 3018 3019} 3020 3021func TestOutputService12ProtocolTestEmptyStringCase1(t *testing.T) { 3022 svc := NewOutputService12ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3023 3024 buf := bytes.NewReader([]byte("<OperationNameResponse><Foo/><RequestId>requestid</RequestId></OperationNameResponse>")) 3025 req, out := svc.OutputService12TestCaseOperation1Request(nil) 3026 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 3027 3028 // set headers 3029 3030 // unmarshal response 3031 restxml.UnmarshalMeta(req) 3032 restxml.Unmarshal(req) 3033 if req.Error != nil { 3034 t.Errorf("expect not error, got %v", req.Error) 3035 } 3036 3037 // assert response 3038 if out == nil { 3039 t.Errorf("expect not to be nil") 3040 } 3041 if e, a := "", *out.Foo; e != a { 3042 t.Errorf("expect %v, got %v", e, a) 3043 } 3044 3045} 3046 3047func TestOutputService13ProtocolTestEnumCase1(t *testing.T) { 3048 svc := NewOutputService13ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3049 3050 buf := bytes.NewReader([]byte("<OperationNameResponse><FooEnum>foo</FooEnum><ListEnums><member>0</member><member>1</member></ListEnums></OperationNameResponse>")) 3051 req, out := svc.OutputService13TestCaseOperation1Request(nil) 3052 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 3053 3054 // set headers 3055 req.HTTPResponse.Header.Set("x-amz-enum", "baz") 3056 3057 // unmarshal response 3058 restxml.UnmarshalMeta(req) 3059 restxml.Unmarshal(req) 3060 if req.Error != nil { 3061 t.Errorf("expect not error, got %v", req.Error) 3062 } 3063 3064 // assert response 3065 if out == nil { 3066 t.Errorf("expect not to be nil") 3067 } 3068 if e, a := "foo", *out.FooEnum; e != a { 3069 t.Errorf("expect %v, got %v", e, a) 3070 } 3071 if e, a := "baz", *out.HeaderEnum; e != a { 3072 t.Errorf("expect %v, got %v", e, a) 3073 } 3074 if e, a := "0", *out.ListEnums[0]; e != a { 3075 t.Errorf("expect %v, got %v", e, a) 3076 } 3077 if e, a := "1", *out.ListEnums[1]; e != a { 3078 t.Errorf("expect %v, got %v", e, a) 3079 } 3080 3081} 3082 3083func TestOutputService13ProtocolTestEnumCase2(t *testing.T) { 3084 svc := NewOutputService13ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3085 3086 buf := bytes.NewReader([]byte("")) 3087 req, out := svc.OutputService13TestCaseOperation2Request(nil) 3088 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 3089 3090 // set headers 3091 3092 // unmarshal response 3093 restxml.UnmarshalMeta(req) 3094 restxml.Unmarshal(req) 3095 if req.Error != nil { 3096 t.Errorf("expect not error, got %v", req.Error) 3097 } 3098 3099 // assert response 3100 if out == nil { 3101 t.Errorf("expect not to be nil") 3102 } 3103 3104} 3105 3106func TestOutputService14ProtocolTestXMLAttributesCase1(t *testing.T) { 3107 svc := NewOutputService14ProtocolTest(unit.Session, &aws.Config{Endpoint: aws.String("https://test")}) 3108 3109 buf := bytes.NewReader([]byte("<SomeOutputDoc xmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\"><ItemsList><Item><ItemDetail xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"Type1\"><ID>id1</ID></ItemDetail></Item><Item><ItemDetail xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"Type2\"><ID>id2</ID></ItemDetail></Item><Item><ItemDetail xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"Type3\"><ID>id3</ID></ItemDetail></Item></ItemsList></SomeOutputDoc>")) 3110 req, out := svc.OutputService14TestCaseOperation1Request(nil) 3111 req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} 3112 3113 // set headers 3114 3115 // unmarshal response 3116 restxml.UnmarshalMeta(req) 3117 restxml.Unmarshal(req) 3118 if req.Error != nil { 3119 t.Errorf("expect not error, got %v", req.Error) 3120 } 3121 3122 // assert response 3123 if out == nil { 3124 t.Errorf("expect not to be nil") 3125 } 3126 if e, a := "id1", *out.ListItems[0].ItemDetail.ID; e != a { 3127 t.Errorf("expect %v, got %v", e, a) 3128 } 3129 if e, a := "Type1", *out.ListItems[0].ItemDetail.Type; e != a { 3130 t.Errorf("expect %v, got %v", e, a) 3131 } 3132 if e, a := "id2", *out.ListItems[1].ItemDetail.ID; e != a { 3133 t.Errorf("expect %v, got %v", e, a) 3134 } 3135 if e, a := "Type2", *out.ListItems[1].ItemDetail.Type; e != a { 3136 t.Errorf("expect %v, got %v", e, a) 3137 } 3138 if e, a := "id3", *out.ListItems[2].ItemDetail.ID; e != a { 3139 t.Errorf("expect %v, got %v", e, a) 3140 } 3141 if e, a := "Type3", *out.ListItems[2].ItemDetail.Type; e != a { 3142 t.Errorf("expect %v, got %v", e, a) 3143 } 3144 3145} 3146