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