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