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