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