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